Index: trunk/psLib/src/math/psPolynomial.c
===================================================================
--- trunk/psLib/src/math/psPolynomial.c	(revision 5813)
+++ trunk/psLib/src/math/psPolynomial.c	(revision 6101)
@@ -7,6 +7,6 @@
 *  polynomials.  It also contains a Gaussian functions.
 *
-*  @version $Revision: 1.134 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2005-12-19 23:58:47 $
+*  @version $Revision: 1.135 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2006-01-21 02:43:31 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -965,4 +965,6 @@
 }
 
+// XXX: The output of this routine is always psF64 while 1D and 2D are
+// dependent on the input vectors.
 psVector *psPolynomial3DEvalVector(const psPolynomial3D *poly,
                                    const psVector *x,
@@ -973,9 +975,9 @@
     PS_ASSERT_POLY_NON_NULL(poly, NULL);
     PS_ASSERT_VECTOR_NON_NULL(x, NULL);
-    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F64, NULL);
+    PS_ASSERT_VECTOR_TYPE_F32_OR_F64(x, NULL);
     PS_ASSERT_VECTOR_NON_NULL(y, NULL);
-    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F64, NULL);
+    PS_ASSERT_VECTOR_TYPE_F32_OR_F64(y, NULL);
     PS_ASSERT_VECTOR_NON_NULL(z, NULL);
-    PS_ASSERT_VECTOR_TYPE(z, PS_TYPE_F64, NULL);
+    PS_ASSERT_VECTOR_TYPE_F32_OR_F64(z, NULL);
 
     psVector *tmp;
@@ -994,10 +996,39 @@
 
     // Evaluate polynomial
-    for (unsigned int i = 0; i < vecLen; i++) {
-        tmp->data.F64[i] = psPolynomial3DEval(poly,
-                                              x->data.F64[i],
-                                              y->data.F64[i],
-                                              z->data.F64[i]);
-    }
+    // XXX: Consult with IfA: is this how they want to handle multiple data types?
+    if ((x->type.type == PS_TYPE_F32) || (y->type.type == PS_TYPE_F32) || (z->type.type == PS_TYPE_F32)) {
+        for (unsigned int i = 0; i < vecLen; i++) {
+            tmp->data.F64[i] = psPolynomial3DEval(poly, x->data.F32[i], y->data.F32[i], z->data.F32[i]);
+        }
+    } else if ((x->type.type == PS_TYPE_F32) || (y->type.type == PS_TYPE_F32) || (z->type.type == PS_TYPE_F64)) {
+        for (unsigned int i = 0; i < vecLen; i++) {
+            tmp->data.F64[i] = psPolynomial3DEval(poly, x->data.F32[i], y->data.F32[i], z->data.F64[i]);
+        }
+    } else if ((x->type.type == PS_TYPE_F32) || (y->type.type == PS_TYPE_F64) || (z->type.type == PS_TYPE_F32)) {
+        for (unsigned int i = 0; i < vecLen; i++) {
+            tmp->data.F64[i] = psPolynomial3DEval(poly, x->data.F32[i], y->data.F64[i], z->data.F32[i]);
+        }
+    } else if ((x->type.type == PS_TYPE_F32) || (y->type.type == PS_TYPE_F64) || (z->type.type == PS_TYPE_F64)) {
+        for (unsigned int i = 0; i < vecLen; i++) {
+            tmp->data.F64[i] = psPolynomial3DEval(poly, x->data.F32[i], y->data.F64[i], z->data.F64[i]);
+        }
+    } else if ((x->type.type == PS_TYPE_F64) || (y->type.type == PS_TYPE_F32) || (z->type.type == PS_TYPE_F32)) {
+        for (unsigned int i = 0; i < vecLen; i++) {
+            tmp->data.F64[i] = psPolynomial3DEval(poly, x->data.F64[i], y->data.F32[i], z->data.F32[i]);
+        }
+    } else if ((x->type.type == PS_TYPE_F64) || (y->type.type == PS_TYPE_F32) || (z->type.type == PS_TYPE_F64)) {
+        for (unsigned int i = 0; i < vecLen; i++) {
+            tmp->data.F64[i] = psPolynomial3DEval(poly, x->data.F64[i], y->data.F32[i], z->data.F32[i]);
+        }
+    } else if ((x->type.type == PS_TYPE_F64) || (y->type.type == PS_TYPE_F64) || (z->type.type == PS_TYPE_F32)) {
+        for (unsigned int i = 0; i < vecLen; i++) {
+            tmp->data.F64[i] = psPolynomial3DEval(poly, x->data.F64[i], y->data.F32[i], z->data.F32[i]);
+        }
+    } else if ((x->type.type == PS_TYPE_F64) || (y->type.type == PS_TYPE_F64) || (z->type.type == PS_TYPE_F64)) {
+        for (unsigned int i = 0; i < vecLen; i++) {
+            tmp->data.F64[i] = psPolynomial3DEval(poly, x->data.F64[i], y->data.F32[i], z->data.F32[i]);
+        }
+    }
+
 
     // Return output vector
@@ -1033,11 +1064,11 @@
     PS_ASSERT_POLY_NON_NULL(poly, NULL);
     PS_ASSERT_VECTOR_NON_NULL(x, NULL);
-    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F64, NULL);
+    PS_ASSERT_VECTOR_TYPE_F32_OR_F64(x, NULL);
     PS_ASSERT_VECTOR_NON_NULL(y, NULL);
-    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F64, NULL);
+    PS_ASSERT_VECTOR_TYPE_F32_OR_F64(y, NULL);
     PS_ASSERT_VECTOR_NON_NULL(z, NULL);
-    PS_ASSERT_VECTOR_TYPE(z, PS_TYPE_F64, NULL);
+    PS_ASSERT_VECTOR_TYPE_F32_OR_F64(z, NULL);
     PS_ASSERT_VECTOR_NON_NULL(t, NULL);
-    PS_ASSERT_VECTOR_TYPE(t, PS_TYPE_F64, NULL);
+    PS_ASSERT_VECTOR_TYPE_F32_OR_F64(t, NULL);
 
     psVector *tmp;
@@ -1057,4 +1088,73 @@
     // Allocoutput vector
     tmp = psVectorAlloc(vecLen, PS_TYPE_F64);
+
+    // Evaluate polynomial
+    // XXX: Consult with IfA: is this how they want to handle multiple data types?
+    if ((x->type.type == PS_TYPE_F32) || (y->type.type == PS_TYPE_F32) || (z->type.type == PS_TYPE_F32) || (t->type.type == PS_TYPE_F32)) {
+        for (unsigned int i = 0; i < vecLen; i++) {
+            tmp->data.F64[i] = psPolynomial4DEval(poly, x->data.F32[i], y->data.F32[i], z->data.F32[i], t->data.F32[i]);
+        }
+    } else if ((x->type.type == PS_TYPE_F32) || (y->type.type == PS_TYPE_F32) || (z->type.type == PS_TYPE_F32) || (t->type.type == PS_TYPE_F64)) {
+        for (unsigned int i = 0; i < vecLen; i++) {
+            tmp->data.F64[i] = psPolynomial4DEval(poly, x->data.F32[i], y->data.F32[i], z->data.F32[i], t->data.F64[i]);
+        }
+    } else if ((x->type.type == PS_TYPE_F32) || (y->type.type == PS_TYPE_F32) || (z->type.type == PS_TYPE_F64) || (t->type.type == PS_TYPE_F32)) {
+        for (unsigned int i = 0; i < vecLen; i++) {
+            tmp->data.F64[i] = psPolynomial4DEval(poly, x->data.F32[i], y->data.F32[i], z->data.F64[i], t->data.F32[i]);
+        }
+    } else if ((x->type.type == PS_TYPE_F32) || (y->type.type == PS_TYPE_F32) || (z->type.type == PS_TYPE_F64) || (t->type.type == PS_TYPE_F64)) {
+        for (unsigned int i = 0; i < vecLen; i++) {
+            tmp->data.F64[i] = psPolynomial4DEval(poly, x->data.F32[i], y->data.F32[i], z->data.F64[i], t->data.F64[i]);
+        }
+    } else if ((x->type.type == PS_TYPE_F32) || (y->type.type == PS_TYPE_F64) || (z->type.type == PS_TYPE_F32) || (t->type.type == PS_TYPE_F32)) {
+        for (unsigned int i = 0; i < vecLen; i++) {
+            tmp->data.F64[i] = psPolynomial4DEval(poly, x->data.F32[i], y->data.F64[i], z->data.F32[i], t->data.F32[i]);
+        }
+    } else if ((x->type.type == PS_TYPE_F32) || (y->type.type == PS_TYPE_F64) || (z->type.type == PS_TYPE_F32) || (t->type.type == PS_TYPE_F64)) {
+        for (unsigned int i = 0; i < vecLen; i++) {
+            tmp->data.F64[i] = psPolynomial4DEval(poly, x->data.F32[i], y->data.F64[i], z->data.F32[i], t->data.F64[i]);
+        }
+    } else if ((x->type.type == PS_TYPE_F32) || (y->type.type == PS_TYPE_F64) || (z->type.type == PS_TYPE_F64) || (t->type.type == PS_TYPE_F32)) {
+        for (unsigned int i = 0; i < vecLen; i++) {
+            tmp->data.F64[i] = psPolynomial4DEval(poly, x->data.F32[i], y->data.F64[i], z->data.F64[i], t->data.F32[i]);
+        }
+    } else if ((x->type.type == PS_TYPE_F32) || (y->type.type == PS_TYPE_F64) || (z->type.type == PS_TYPE_F64) || (t->type.type == PS_TYPE_F64)) {
+        for (unsigned int i = 0; i < vecLen; i++) {
+            tmp->data.F64[i] = psPolynomial4DEval(poly, x->data.F32[i], y->data.F64[i], z->data.F64[i], t->data.F64[i]);
+        }
+    } else if ((x->type.type == PS_TYPE_F64) || (y->type.type == PS_TYPE_F32) || (z->type.type == PS_TYPE_F32) || (t->type.type == PS_TYPE_F32)) {
+        for (unsigned int i = 0; i < vecLen; i++) {
+            tmp->data.F64[i] = psPolynomial4DEval(poly, x->data.F64[i], y->data.F32[i], z->data.F32[i], t->data.F32[i]);
+        }
+    } else if ((x->type.type == PS_TYPE_F64) || (y->type.type == PS_TYPE_F32) || (z->type.type == PS_TYPE_F32) || (t->type.type == PS_TYPE_F64)) {
+        for (unsigned int i = 0; i < vecLen; i++) {
+            tmp->data.F64[i] = psPolynomial4DEval(poly, x->data.F64[i], y->data.F32[i], z->data.F32[i], t->data.F64[i]);
+        }
+    } else if ((x->type.type == PS_TYPE_F64) || (y->type.type == PS_TYPE_F32) || (z->type.type == PS_TYPE_F64) || (t->type.type == PS_TYPE_F32)) {
+        for (unsigned int i = 0; i < vecLen; i++) {
+            tmp->data.F64[i] = psPolynomial4DEval(poly, x->data.F64[i], y->data.F32[i], z->data.F64[i], t->data.F32[i]);
+        }
+    } else if ((x->type.type == PS_TYPE_F64) || (y->type.type == PS_TYPE_F32) || (z->type.type == PS_TYPE_F64) || (t->type.type == PS_TYPE_F64)) {
+        for (unsigned int i = 0; i < vecLen; i++) {
+            tmp->data.F64[i] = psPolynomial4DEval(poly, x->data.F64[i], y->data.F32[i], z->data.F64[i], t->data.F64[i]);
+        }
+    } else if ((x->type.type == PS_TYPE_F64) || (y->type.type == PS_TYPE_F64) || (z->type.type == PS_TYPE_F32) || (t->type.type == PS_TYPE_F32)) {
+        for (unsigned int i = 0; i < vecLen; i++) {
+            tmp->data.F64[i] = psPolynomial4DEval(poly, x->data.F64[i], y->data.F64[i], z->data.F32[i], t->data.F32[i]);
+        }
+    } else if ((x->type.type == PS_TYPE_F64) || (y->type.type == PS_TYPE_F64) || (z->type.type == PS_TYPE_F32) || (t->type.type == PS_TYPE_F64)) {
+        for (unsigned int i = 0; i < vecLen; i++) {
+            tmp->data.F64[i] = psPolynomial4DEval(poly, x->data.F64[i], y->data.F64[i], z->data.F32[i], t->data.F64[i]);
+        }
+    } else if ((x->type.type == PS_TYPE_F64) || (y->type.type == PS_TYPE_F64) || (z->type.type == PS_TYPE_F64) || (t->type.type == PS_TYPE_F32)) {
+        for (unsigned int i = 0; i < vecLen; i++) {
+            tmp->data.F64[i] = psPolynomial4DEval(poly, x->data.F64[i], y->data.F64[i], z->data.F64[i], t->data.F32[i]);
+        }
+    } else if ((x->type.type == PS_TYPE_F64) || (y->type.type == PS_TYPE_F64) || (z->type.type == PS_TYPE_F64) || (t->type.type == PS_TYPE_F64)) {
+        for (unsigned int i = 0; i < vecLen; i++) {
+            tmp->data.F64[i] = psPolynomial4DEval(poly, x->data.F64[i], y->data.F64[i], z->data.F64[i], t->data.F64[i]);
+        }
+    }
+
 
     // Evaluate polynomial