Index: trunk/psLib/src/math/psConstants.h
===================================================================
--- trunk/psLib/src/math/psConstants.h	(revision 6449)
+++ trunk/psLib/src/math/psConstants.h	(revision 6484)
@@ -6,6 +6,6 @@
  *  @author GLG, MHPCC
  *
- *  @version $Revision: 1.85 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-02-17 00:56:48 $
+ *  @version $Revision: 1.86 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-02-24 23:43:15 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -312,5 +312,5 @@
 if (VEC->n != SIZE) { \
     psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
-            "psVector %s has size %d, should be %d." \
+            "psVector %s has size %d, should be %d.", \
             #VEC, VEC->n, SIZE); \
     return(RVAL); \
Index: trunk/psLib/src/math/psMinimizeLMM.c
===================================================================
--- trunk/psLib/src/math/psMinimizeLMM.c	(revision 6449)
+++ trunk/psLib/src/math/psMinimizeLMM.c	(revision 6484)
@@ -10,6 +10,6 @@
  *  @author EAM, IfA
  *
- *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-02-07 23:14:21 $
+ *  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-02-24 23:43:15 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -239,4 +239,5 @@
     psF64 ymodel;
     psVector *deriv = psVectorAlloc(params->n, PS_TYPE_F32);
+    deriv->n = deriv->nalloc;
 
     // zero alpha and beta for summing below
@@ -370,4 +371,7 @@
     psVector *Beta   = psVectorAlloc(params->n, PS_TYPE_F64);
     psVector *Params = psVectorAlloc(params->n, PS_TYPE_F32);
+    beta->n = beta->nalloc;
+    Beta->n = Beta->nalloc;
+    Params->n = Params->nalloc;
     psVector *dy     = NULL;
     psF64 Chisq = 0.0;
@@ -385,4 +389,7 @@
         param_min = psVectorAlloc(params->n, PS_TYPE_F32);
         param_max = psVectorAlloc(params->n, PS_TYPE_F32);
+        beta_lim->n = beta_lim->nalloc;
+        param_min->n = param_min->nalloc;
+        param_max->n = param_max->nalloc;
         for (int i = 0; i < params->n; i++) {
             beta_lim->data.F32[i] = covar->data.F64[0][i];
@@ -402,4 +409,5 @@
     } else {
         dy = psVectorAlloc(y->n, PS_TYPE_F32);
+        dy->n = dy->nalloc;
         psVectorInit(dy, 1.0);
     }
Index: trunk/psLib/src/math/psMinimizePolyFit.c
===================================================================
--- trunk/psLib/src/math/psMinimizePolyFit.c	(revision 6449)
+++ trunk/psLib/src/math/psMinimizePolyFit.c	(revision 6484)
@@ -10,6 +10,6 @@
  *  @author EAM, IfA
  *
- *  @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-02-02 21:09:07 $
+ *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-02-24 23:43:15 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -44,8 +44,10 @@
     for (psS32 i = 0 ; i < SIZE ; i++) { \
         VEC->data.F64[i] = ((2.0 / ((psF64) (SIZE - 1))) * ((psF64) i)) - 1.0; \
+        VEC->n++; \
     }\
 } else if (TYPE == PS_TYPE_F32){ \
     for (psS32 i = 0 ; i < SIZE ; i++) { \
         VEC->data.F32[i] = ((2.0 / ((psF32) (SIZE - 1))) * ((psF32) i)) - 1.0; \
+        VEC->n++; \
     }\
 }\
@@ -87,6 +89,8 @@
     if (sums == NULL) {
         sums = psVectorAlloc(nSum, PS_TYPE_F64);
+        sums->n = sums->nalloc;
     } else if (nSum > sums->n) {
         sums = psVectorRealloc(sums, nSum);
+        sums->n = sums->nalloc;
     }
 
@@ -305,5 +309,5 @@
     linear equations which can be easily solved.  The resulting vector is the
     coefficients of the Chebyshev polys.
-    
+ 
     This method is significantly slower than the standard NR algorithm.  It
     was explicitly requested that we not use the NR algorithm.
@@ -371,4 +375,5 @@
         }
         B->data.F64[i] = ordPoly->coeff[i];
+        B->n++;
     }
 
@@ -534,4 +539,5 @@
     // Compute the B vector
     psVector *B = psVectorAlloc(NUM_POLY, PS_TYPE_F64);
+    B->n = B->nalloc;
     for (psS32 i = 0 ; i < NUM_POLY ; i++) {
         B->data.F64[i] = 0.0;
@@ -780,4 +786,5 @@
     A = psImageAlloc(nTerm, nTerm, PS_TYPE_F64);
     B = psVectorAlloc(nTerm, PS_TYPE_F64);
+    B->n = B->nalloc;
     // Initialize data structures.
     if (!psImageInit(A, 0.0) || !psVectorInit(B, 0.0)) {
@@ -1045,4 +1052,5 @@
     psVector *fit   = NULL;
     psVector *resid = psVectorAlloc(f->n, PS_TYPE_F64);
+    resid->n = resid->nalloc;
 
     // eventual expansion: user supplies one of various stats option pairs,
@@ -1205,4 +1213,5 @@
     A = psImageAlloc(nTerm, nTerm, PS_TYPE_F64);
     B = psVectorAlloc(nTerm, PS_TYPE_F64);
+    B->n = B->nalloc;
     // Initialize data structures.
     if (!psImageInit(A, 0.0) || !psVectorInit(B, 0.0)) {
@@ -1462,4 +1471,5 @@
     }
     psVector *resid = psVectorAlloc(f->n, PS_TYPE_F64);
+    resid->n = resid->nalloc;
 
     // eventual expansion: user supplies one of various stats option pairs,
@@ -1630,4 +1640,5 @@
     A = psImageAlloc(nTerm, nTerm, PS_TYPE_F64);
     B = psVectorAlloc(nTerm, PS_TYPE_F64);
+    B->n = B->nalloc;
     // Initialize data structures.
     if (!psImageInit(A, 0.0) || !psVectorInit(B, 0.0)) {
@@ -2002,4 +2013,5 @@
     psVector *fit   = NULL;
     psVector *resid = psVectorAlloc(f->n, PS_TYPE_F64);
+    resid->n = resid->nalloc;
 
     // eventual expansion: user supplies one of various stats option pairs,
@@ -2174,4 +2186,5 @@
     A = psImageAlloc(nTerm, nTerm, PS_TYPE_F64);
     B = psVectorAlloc(nTerm, PS_TYPE_F64);
+    B->n = B->nalloc;
     // Initialize data structures.
     if (!psImageInit(A, 0.0) || !psVectorInit(B, 0.0)) {
@@ -2596,4 +2609,5 @@
     psVector *fit   = NULL;
     psVector *resid = psVectorAlloc(f->n, PS_TYPE_F64);
+    resid->n = resid->nalloc;
 
     // eventual expansion: user supplies one of various stats option pairs,
Index: trunk/psLib/src/math/psMinimizePowell.c
===================================================================
--- trunk/psLib/src/math/psMinimizePowell.c	(revision 6449)
+++ trunk/psLib/src/math/psMinimizePowell.c	(revision 6484)
@@ -11,6 +11,6 @@
  *  NOTE: XXX: The SDR is silent about data types.  F32 is implemented here.
  *
- *  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-02-18 00:56:44 $
+ *  @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-02-24 23:43:15 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -525,6 +525,7 @@
         p_psMemSetPersistent(myParamMask, true);
         p_psMemSetPersistent(myParamMask->data.U8, true);
-        for (i=0;i<myParamMask->n;i++) {
+        for (i=0;i<myParamMask->nalloc;i++) {
             myParamMask->data.U8[i] = 0;
+            myParamMask->n++;
         }
     } else {
@@ -543,4 +544,5 @@
                 ((psVector *) (v->data[i]))->data.F32[j] = 0.0;
             }
+            ((psVector *)(v->data[i]))->n++;
         }
         v->n++;
@@ -550,4 +552,5 @@
     for (i=0;i<numDims;i++) {
         Q->data.F32[i] = params->data.F32[i];
+        Q->n++;
     }
 
@@ -595,4 +598,5 @@
             if (myParamMask->data.U8[i] == 0) {
                 u->data.F32[i] = Q->data.F32[i] - params->data.F32[i];
+                u->n++;
 
                 psTrace(__func__, 6, "u[i]=Q[i]-P[i] (%f = %f - %f)\n", u->data.F32[i],
@@ -602,4 +606,5 @@
             } else {
                 u->data.F32[i] = 0.0;
+                u->n++;
             }
         }
Index: trunk/psLib/src/math/psPolynomial.c
===================================================================
--- trunk/psLib/src/math/psPolynomial.c	(revision 6449)
+++ trunk/psLib/src/math/psPolynomial.c	(revision 6484)
@@ -7,6 +7,6 @@
 *  polynomials.  It also contains a Gaussian functions.
 *
-*  @version $Revision: 1.143 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2006-02-17 00:56:48 $
+*  @version $Revision: 1.144 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2006-02-24 23:43:15 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -589,4 +589,5 @@
     for (unsigned int i = 0; i < Npts; i++) {
         gauss->data.F32[i] = mean + p_psRandomGaussian(r, sigma);
+        gauss->n++;
     }
     psFree(r);
@@ -802,4 +803,5 @@
         for (unsigned int i=0;i<x->n;i++) {
             tmp->data.F64[i] = psPolynomial1DEval(poly, x->data.F64[i]);
+            tmp->n++;
         }
         break;
@@ -808,4 +810,5 @@
         for (unsigned int i=0;i<x->n;i++) {
             tmp->data.F32[i] = psPolynomial1DEval(poly, x->data.F32[i]);
+            tmp->n++;
         }
         break;
@@ -869,4 +872,5 @@
         for (unsigned int i=0; i<vecLen; i++) {
             tmp->data.F32[i] = psPolynomial2DEval(poly,x->data.F32[i],y->data.F32[i]);
+            tmp->n++;
         }
         break;
@@ -883,4 +887,5 @@
         for (unsigned int i=0; i<vecLen; i++) {
             tmp->data.F64[i] = psPolynomial2DEval(poly,x->data.F64[i],y->data.F64[i]);
+            tmp->n++;
         }
         break;
@@ -944,35 +949,59 @@
     // 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)) {
-        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.F64[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.F64[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.F64[i], z->data.F64[i]);
+    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]);
+            tmp->n++;
+        }
+    } 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]);
+            tmp->n++;
+        }
+    } 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]);
+            tmp->n++;
+        }
+    } 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]);
+            tmp->n++;
+        }
+    } 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]);
+            tmp->n++;
+        }
+    } 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.F64[i]);
+            tmp->n++;
+        }
+    } 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.F64[i], z->data.F32[i]);
+            tmp->n++;
+        }
+    } 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.F64[i], z->data.F64[i]);
+            tmp->n++;
         }
     }
@@ -1040,68 +1069,116 @@
     // 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],
+    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]);
+            tmp->n++;
+        }
+    } 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]);
+            tmp->n++;
+        }
+    } 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]);
+            tmp->n++;
+        }
+    } 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]);
+            tmp->n++;
+        }
+    } 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]);
+            tmp->n++;
+        }
+    } 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]);
+            tmp->n++;
+        }
+    } 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]);
+            tmp->n++;
+        }
+    } 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]);
+            tmp->n++;
+        }
+    } 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]);
+            tmp->n++;
+        }
+    } 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]);
+            tmp->n++;
+        }
+    } 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]);
+            tmp->n++;
+        }
+    } 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]);
+            tmp->n++;
+        }
+    } 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]);
+            tmp->n++;
+        }
+    } 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]);
+            tmp->n++;
+        }
+    } 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]);
+            tmp->n++;
+        }
+    } 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]);
+            tmp->n++;
         }
     }
Index: trunk/psLib/src/math/psSpline.c
===================================================================
--- trunk/psLib/src/math/psSpline.c	(revision 6449)
+++ trunk/psLib/src/math/psSpline.c	(revision 6484)
@@ -1,11 +1,11 @@
 /** @file psSpline.c
 *
-*  @brief Contains basic spline allocation, deallocation, fitting, 
+*  @brief Contains basic spline allocation, deallocation, fitting,
 *         and evaluation routines.
 *
 *  This file contains the routines that allocate, free, and evaluate splines.
 *
-*  @version $Revision: 1.136 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2006-02-17 00:56:48 $
+*  @version $Revision: 1.137 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2006-02-24 23:43:15 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -239,8 +239,10 @@
             for (psS32 i = 0 ; i < x->n ; i++) {
                 spline->knots->data.F32[i] = x->data.F32[i];
+                spline->knots->n++;
             }
         } else if (x->type.type == PS_TYPE_F64) {
             for (psS32 i = 0 ; i < x->n ; i++) {
                 spline->knots->data.F32[i] = (psF32) x->data.F64[i];
+                spline->knots->n++;
             }
         }
@@ -248,4 +250,5 @@
         for (psS32 i = 0 ; i < y->n ; i++) {
             spline->knots->data.F32[i] = (psF32) i;
+            spline->knots->n++;
         }
     }
@@ -412,8 +415,10 @@
         for (psS32 i=0;i<x->n;i++) {
             tmpVector->data.F32[i] = psSpline1DEval(spline, x->data.F32[i]);
+            tmpVector->n++;
         }
     } else if (x->type.type == PS_TYPE_F64) {
         for (psS32 i=0;i<x->n;i++) {
             tmpVector->data.F32[i] = psSpline1DEval(spline, (psF32) x->data.F64[i]);
+            tmpVector->n++;
         }
     }
Index: trunk/psLib/src/math/psStats.c
===================================================================
--- trunk/psLib/src/math/psStats.c	(revision 6449)
+++ trunk/psLib/src/math/psStats.c	(revision 6484)
@@ -16,6 +16,6 @@
  * use ->min and ->max (PS_STAT_USE_RANGE)
  *
- *  @version $Revision: 1.169 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-02-18 00:56:44 $
+ *  @version $Revision: 1.170 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-02-24 23:43:15 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -569,4 +569,5 @@
     // Allocate temporary vectors for the data.
     unsortedVector = psVectorAlloc(nValues, PS_TYPE_F32);
+    unsortedVector->n = nValues;
 
     // Determine if we must only use data points within a min/max range.
@@ -657,4 +658,5 @@
     psS32 numBins = histogram->nums->n;
     psVector *smooth = psVectorAlloc(numBins, PS_TYPE_F32);
+    smooth->n = smooth->nalloc;
     psS32 jMin = 0;
     psS32 jMax = 0;
@@ -783,4 +785,5 @@
     // Allocate temporary vectors for the data.
     unsortedVector = psVectorAlloc(nValues, PS_TYPE_F32);
+    unsortedVector->n = unsortedVector->nalloc;
 
     if (stats->options & PS_STAT_USE_RANGE) {
@@ -1037,4 +1040,5 @@
     // However, we do no want to modify the original mask vector.
     tmpMask = psVectorAlloc(myVector->n, PS_TYPE_U8);
+    tmpMask->n = tmpMask->nalloc;
 
     // If we were called with a mask vector, then initialize the temporary
@@ -1198,4 +1202,6 @@
     psVector *x = psVectorAlloc(3, PS_TYPE_F64);
     psVector *y = psVectorAlloc(3, PS_TYPE_F64);
+    x->n = 3;
+    y->n = 3;
     psF32 tmpFloat = 0.0f;
 
@@ -1313,4 +1319,5 @@
     if (deriv == NULL) {
         deriv = psVectorAlloc(2, PS_TYPE_F32);
+        deriv->n = 2;
     } else {
         PS_ASSERT_VECTOR_SIZE(deriv, 2, NAN);
@@ -1365,4 +1372,5 @@
     psS32 rcBool = false;
     psVector *tmpMaskVec = psVectorAlloc(myVector->n, PS_TYPE_U8);
+    tmpMaskVec->n = tmpMaskVec->nalloc;
     if (maskVector != NULL) {
         for (psS32 i = 0 ; i < myVector->n ; i++) {
@@ -1850,4 +1858,5 @@
         psArray *x = psArrayAlloc((1 + (binMax - binMin)));
         psS32 j = 0;
+        y->n = y->nalloc;
 
         for (psS32 i = binMin ; i <= binMax ; i++) {
@@ -1856,4 +1865,5 @@
             x->n++;
             ((psVector *) x->data[j])->data.F32[0] = PS_BIN_MIDPOINT(newHistogram, i);
+            ((psVector *) x->data[j])->n++;
             j++;
         }
@@ -1886,4 +1896,5 @@
         psMinimization *min = psMinimizationAlloc(100, 0.01);
         psVector *params = psVectorAlloc(2, PS_TYPE_F32);
+        params->n = params->nalloc;
         // Initial guess for the mean ([0]) and standard dev.
         params->data.F32[0] = stats->robustMedian;
@@ -2049,6 +2060,7 @@
     // Allocate the bins, and initialize them to zero.
     newHist->nums = psVectorAlloc(n, PS_TYPE_F32);
-    for (i = 0; i < newHist->nums->n; i++) {
+    for (i = 0; i < newHist->nums->nalloc; i++) {
         newHist->nums->data.F32[i] = 0.0;
+        newHist->nums->n++;
     }
 
@@ -2094,6 +2106,7 @@
     // then there are N-1 bins.
     newHist->nums = psVectorAlloc((bounds->n) - 1, PS_TYPE_F32);
-    for (i = 0; i < newHist->nums->n; i++) {
+    for (i = 0; i < newHist->nums->nalloc; i++) {
         newHist->nums->data.F32[i] = 0.0;
+        newHist->nums->n++;
     }
 
@@ -2366,4 +2379,5 @@
         for (i = 0; i < in->n; i++) {
             tmp->data.F32[i] = (psF32)in->data.S8[i];
+            tmp->n++;
         }
     } else if (in->type.type == PS_TYPE_S16) {
@@ -2371,4 +2385,5 @@
         for (i = 0; i < in->n; i++) {
             tmp->data.F32[i] = (psF32) in->data.S16[i];
+            tmp->n++;
         }
     } else if (in->type.type == PS_TYPE_S32) {
@@ -2376,4 +2391,5 @@
         for (i = 0; i < in->n; i++) {
             tmp->data.F32[i] = (psF32)in->data.S32[i];
+            tmp->n++;
         }
     } else if (in->type.type == PS_TYPE_S64) {
@@ -2381,4 +2397,5 @@
         for (i = 0; i < in->n; i++) {
             tmp->data.F32[i] = (psF32)in->data.S64[i];
+            tmp->n++;
         }
     } else if (in->type.type == PS_TYPE_U8) {
@@ -2386,4 +2403,5 @@
         for (i = 0; i < in->n; i++) {
             tmp->data.F32[i] = (psF32)in->data.U8[i];
+            tmp->n++;
         }
     } else if (in->type.type == PS_TYPE_U16) {
@@ -2391,4 +2409,5 @@
         for (i = 0; i < in->n; i++) {
             tmp->data.F32[i] = (psF32)in->data.U16[i];
+            tmp->n++;
         }
     } else if (in->type.type == PS_TYPE_U32) {
@@ -2396,4 +2415,5 @@
         for (i = 0; i < in->n; i++) {
             tmp->data.F32[i] = (psF32)in->data.U32[i];
+            tmp->n++;
         }
     } else if (in->type.type == PS_TYPE_U64) {
@@ -2401,4 +2421,5 @@
         for (i = 0; i < in->n; i++) {
             tmp->data.F32[i] = (psF32)in->data.U64[i];
+            tmp->n++;
         }
     } else if (in->type.type == PS_TYPE_F64) {
@@ -2406,4 +2427,5 @@
         for (i = 0; i < in->n; i++) {
             tmp->data.F32[i] = (psF32)in->data.F64[i];
+            tmp->n++;
         }
     } else if (in->type.type == PS_TYPE_F32) {
@@ -2463,7 +2485,12 @@
     inF32 = p_psConvertToF32((psVector *) in);
     if (inF32 == NULL) {
-        inF32 = (psVector *) in;
-        mustFreeVectorIn = 0;
-    }
+        //        printf("\n\ninF32 is NULL\n\n");
+        //        inF32 = (psVector *) in;
+        //        mustFreeVectorIn = 0;
+        inF32 = psVectorCopy(inF32, in, PS_TYPE_F32);
+        inF32->n = inF32->nalloc;
+        mustFreeVectorIn = 1;
+    }
+    //    else printf("\ninF32 has n=%ld, nalloc=%ld\n", inF32->n, inF32->nalloc);
     errorsF32 = p_psConvertToF32((psVector *) errors);
     if (errorsF32 == NULL) {
@@ -2471,5 +2498,6 @@
         mustFreeVectorErrors = 0;
     }
-
+    //    inF32->n = inF32->nalloc;
+    //    errorsF32->n = errorsF32->nalloc;
     if ((stats->options & PS_STAT_USE_RANGE) && (stats->min >= stats->max)) {
         PS_ASSERT_FLOAT_LARGER_THAN_OR_EQUAL(stats->max, stats->min, stats);