Index: trunk/psLib/test/math/tst_psPolyFit4D.c
===================================================================
--- trunk/psLib/test/math/tst_psPolyFit4D.c	(revision 6527)
+++ trunk/psLib/test/math/tst_psPolyFit4D.c	(revision 7105)
@@ -11,7 +11,7 @@
 #include "pslib.h"
 #include "psTest.h"
-#define NUM_DATA 35
+#define NUM_DATA 30
 #define POLY_ORDER_X 2
-#define POLY_ORDER_Y 3
+#define POLY_ORDER_Y 2
 #define POLY_ORDER_Z 2
 #define POLY_ORDER_T 2
@@ -33,5 +33,5 @@
 #define ERROR_TOLERANCE 0.10
 #define YERR 10.0
-#define VERBOSE 0
+#define VERBOSE 1
 #define NUM_ITERATIONS 5
 #define CLIP_SIGMA 4.0
@@ -82,5 +82,5 @@
 }
 
-psS32 genericTest(
+bool genericTest(
     psU32 flags,
     psS32 polyOrderX,
@@ -92,5 +92,5 @@
 {
     psS32 currentId = psMemGetId();
-    psS32 testStatus = true;
+    bool testStatus = true;
     psS32 memLeaks = 0;
     psPolynomial4D *myPoly = NULL;
@@ -108,4 +108,25 @@
     printPositiveTestHeader(stdout, "psMinimize functions", "4D Polynomial Fitting Functions");
 
+    psVector *xTruth = psVectorAlloc(numData, PS_TYPE_F64);
+    psVector *yTruth = psVectorAlloc(numData, PS_TYPE_F64);
+    psVector *zTruth = psVectorAlloc(numData, PS_TYPE_F64);
+    psVector *tTruth = psVectorAlloc(numData, PS_TYPE_F64);
+    psVector *fTruth = psVectorAlloc(numData, PS_TYPE_F64);
+    xTruth->n = numData;
+    yTruth->n = numData;
+    zTruth->n = numData;
+    tTruth->n = numData;
+    fTruth->n = numData;
+    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Using known seed
+    for (int i = 0; i < numData; i++) {
+        xTruth->data.F64[i] = 2.0*psRandomUniform(rng) - 1.0;
+        yTruth->data.F64[i] = 2.0*psRandomUniform(rng) - 1.0;
+        zTruth->data.F64[i] = 2.0*psRandomUniform(rng) - 1.0;
+        tTruth->data.F64[i] = 2.0*psRandomUniform(rng) - 1.0;
+        fTruth->data.F64[i] = setData(xTruth->data.F64[i], yTruth->data.F64[i],
+                                      zTruth->data.F64[i], tTruth->data.F64[i]);
+    }
+    psFree(rng);
+
     if (expectedRC == false) {
         printf("This test should generate an error message, and return NULL.\n");
@@ -129,27 +150,15 @@
     if (flags & TS00_X_F32) {
         printf(" using a psF32 x vector\n");
-        x = psVectorAlloc(numData, PS_TYPE_F32);
-        x->n = numData;
-        for (psS32 i=0;i<numData;i++) {
-            x->data.F32[i] = (psF32) i;
-        }
+        x = psVectorCopy(NULL, xTruth, PS_TYPE_F32);
     }
 
     if (flags & TS00_X_S32) {
         printf(" using a psS32 x vector\n");
-        x = psVectorAlloc(numData, PS_TYPE_S32);
-        x->n = numData;
-        for (psS32 i=0;i<numData;i++) {
-            x->data.S32[i] = (psS32) i;
-        }
+        x = psVectorCopy(NULL, xTruth, PS_TYPE_S32);
     }
 
     if (flags & TS00_X_F64) {
         printf(" using a psF64 x vector\n");
-        x = psVectorAlloc(numData, PS_TYPE_F64);
-        x->n = numData;
-        for (psS32 i=0;i<numData;i++) {
-            x->data.F64[i] = (psF64) i;
-        }
+        x = psVectorCopy(NULL, xTruth, PS_TYPE_F64);
     }
 
@@ -161,27 +170,15 @@
     if (flags & TS00_Y_F32) {
         printf(" using a psF32 y vector\n");
-        y = psVectorAlloc(numData, PS_TYPE_F32);
-        y->n = numData;
-        for (psS32 i=0;i<numData;i++) {
-            y->data.F32[i] = (psF32) i;
-        }
+        y = psVectorCopy(NULL, yTruth, PS_TYPE_F32);
     }
 
     if (flags & TS00_Y_S32) {
         printf(" using a psS32 y vector\n");
-        y = psVectorAlloc(numData, PS_TYPE_S32);
-        y->n = numData;
-        for (psS32 i=0;i<numData;i++) {
-            y->data.S32[i] = (psS32) i;
-        }
+        y = psVectorCopy(NULL, yTruth, PS_TYPE_S32);
     }
 
     if (flags & TS00_Y_F64) {
         printf(" using a psF64 y vector\n");
-        y = psVectorAlloc(numData, PS_TYPE_F64);
-        y->n = numData;
-        for (psS32 i=0;i<numData;i++) {
-            y->data.F64[i] = (psF64) i;
-        }
+        y = psVectorCopy(NULL, yTruth, PS_TYPE_F64);
     }
 
@@ -192,27 +189,15 @@
     if (flags & TS00_Z_F32) {
         printf(" using a psF32 z vector\n");
-        z = psVectorAlloc(numData, PS_TYPE_F32);
-        z->n = numData;
-        for (psS32 i=0;i<numData;i++) {
-            z->data.F32[i] = (psF32) i;
-        }
+        z = psVectorCopy(NULL, zTruth, PS_TYPE_F32);
     }
 
     if (flags & TS00_Z_S32) {
         printf(" using a psS32 z vector\n");
-        z = psVectorAlloc(numData, PS_TYPE_S32);
-        z->n = numData;
-        for (psS32 i=0;i<numData;i++) {
-            z->data.S32[i] = (psS32) i;
-        }
+        z = psVectorCopy(NULL, zTruth, PS_TYPE_S32);
     }
 
     if (flags & TS00_Z_F64) {
         printf(" using a psF64 z vector\n");
-        z = psVectorAlloc(numData, PS_TYPE_F64);
-        z->n = numData;
-        for (psS32 i=0;i<numData;i++) {
-            z->data.F64[i] = (psF64) i;
-        }
+        z = psVectorCopy(NULL, zTruth, PS_TYPE_F64);
     }
 
@@ -223,27 +208,15 @@
     if (flags & TS00_T_F32) {
         printf(" using a psF32 t vector\n");
-        t = psVectorAlloc(numData, PS_TYPE_F32);
-        t->n = numData;
-        for (psS32 i=0;i<numData;i++) {
-            t->data.F32[i] = (psF32) i;
-        }
+        t = psVectorCopy(NULL, tTruth, PS_TYPE_F32);
     }
 
     if (flags & TS00_T_S32) {
         printf(" using a psS32 t vector\n");
-        t = psVectorAlloc(numData, PS_TYPE_S32);
-        t->n = numData;
-        for (psS32 i=0;i<numData;i++) {
-            t->data.S32[i] = (psS32) i;
-        }
+        t = psVectorCopy(NULL, tTruth, PS_TYPE_S32);
     }
 
     if (flags & TS00_T_F64) {
         printf(" using a psF64 t vector\n");
-        t = psVectorAlloc(numData, PS_TYPE_F64);
-        t->n = numData;
-        for (psS32 i=0;i<numData;i++) {
-            t->data.F64[i] = (psF64) i;
-        }
+        t = psVectorCopy(NULL, tTruth, PS_TYPE_F64);
     }
 
@@ -255,9 +228,5 @@
     if (flags & TS00_F_F32) {
         printf(" using a psF32 f vector\n");
-        f = psVectorAlloc(numData, PS_TYPE_F32);
-        f->n = numData;
-        for (psS32 i=0;i<numData;i++) {
-            f->data.F32[i] = setData((psF32) i, (psF32) i, (psF32) i, (psF32) i);
-        }
+        f = psVectorCopy(NULL, fTruth, PS_TYPE_F32);
         // Set a few outliers in the data.
         if (OUTLIERS && (flags & TS00_CLIP_FIT)) {
@@ -266,19 +235,9 @@
             f->data.F32[3*numData/4]*= 2.0;
         }
-
-        if (VERBOSE) {
-            for (psS32 i=0;i<numData;i++) {
-                printf("Original data %d: (%.1f %.1f)\n", i, (psF32) i, f->data.F32[i]);
-            }
-        }
     }
 
     if (flags & TS00_F_S32) {
         printf(" using a psS32 f vector\n");
-        f = psVectorAlloc(numData, PS_TYPE_S32);
-        f->n = numData;
-        for (psS32 i=0;i<numData;i++) {
-            f->data.S32[i] = (psS32) setData((psF32) i, (psF32) i, (psF32) i, (psF32) i);
-        }
+        f = psVectorCopy(NULL, fTruth, PS_TYPE_S32);
         // Set a few outliers in the data.
         if (OUTLIERS && (flags & TS00_CLIP_FIT)) {
@@ -287,19 +246,9 @@
             f->data.S32[3*numData/4]*= 2.0;
         }
-
-        if (VERBOSE) {
-            for (psS32 i=0;i<numData;i++) {
-                printf("Original data %d: (%.1f %d)\n", i, (psF32) i, f->data.S32[i]);
-            }
-        }
     }
 
     if (flags & TS00_F_F64) {
         printf(" using a psF64 f vector\n");
-        f = psVectorAlloc(numData, PS_TYPE_F64);
-        f->n = numData;
-        for (psS32 i=0;i<numData;i++) {
-            f->data.F64[i] = (psF64) setData((psF32) i, (psF32) i, (psF32) i, (psF32) i);
-        }
+        f = psVectorCopy(NULL, fTruth, PS_TYPE_F64);
         // Set a few outliers in the data.
         if (OUTLIERS && (flags & TS00_CLIP_FIT)) {
@@ -307,10 +256,4 @@
             f->data.F64[numData/2]*= 2.0;
             f->data.F64[3*numData/4]*= 2.0;
-        }
-
-        if (VERBOSE) {
-            for (psS32 i=0;i<numData;i++) {
-                printf("Original data %d: (%.1f %.1f)\n", i, (psF32) i, f->data.F64[i]);
-            }
         }
     }
@@ -399,75 +342,25 @@
         }
 
-        for (psS32 i=0 ;i<numData; i++) {
+        psVector *result = psPolynomial4DEvalVector(myPoly, xTruth, yTruth, zTruth, tTruth);
+        for (int i=0;i<numData; i++) {
             // Skip the outliers.
             if ((i == numData/4) || (i == numData/2) || (i == 3*numData/4)) {
                 continue;
             }
-            psF32 expectData;
-            psF32 xData;
-            psF32 yData;
-            psF32 zData;
-            psF32 tData;
-            if (flags & TS00_F_F32) {
-                expectData = f->data.F32[i];
-            } else if (flags & TS00_F_F64) {
-                expectData = (psF32) f->data.F64[i];
-            } else if (flags & TS00_F_S32) {
-                expectData = (psF32) f->data.S32[i];
-            }
-
-            if (flags & TS00_X_F32) {
-                xData = x->data.F32[i];
-            } else if (flags & TS00_X_F64) {
-                xData = (psF32) x->data.F64[i];
-            } else if (flags & TS00_X_S32) {
-                xData = (psF32) x->data.S32[i];
-            } else if (flags & TS00_X_NULL) {
-                xData = (psF32) i;
-            }
-
-            if (flags & TS00_Y_F32) {
-                yData = y->data.F32[i];
-            } else if (flags & TS00_Y_F64) {
-                yData = (psF32) y->data.F64[i];
-            } else if (flags & TS00_Y_S32) {
-                yData = (psF32) y->data.S32[i];
-            } else if (flags & TS00_Y_NULL) {
-                yData = (psF32) i;
-            }
-
-            if (flags & TS00_Z_F32) {
-                zData = z->data.F32[i];
-            } else if (flags & TS00_Z_F64) {
-                zData = (psF32) z->data.F64[i];
-            } else if (flags & TS00_Z_S32) {
-                zData = (psF32) z->data.S32[i];
-            } else if (flags & TS00_Z_NULL) {
-                zData = (psF32) i;
-            }
-
-            if (flags & TS00_T_F32) {
-                tData = t->data.F32[i];
-            } else if (flags & TS00_T_F64) {
-                tData = (psF32) t->data.F64[i];
-            } else if (flags & TS00_T_S32) {
-                tData = (psF32) t->data.S32[i];
-            } else if (flags & TS00_T_NULL) {
-                tData = (psF32) i;
-            }
-
-            psF32 actualData = psPolynomial4DEval(myPoly, xData, yData, zData, tData);
+            psF32 expectData = fTruth->data.F64[i];
+            psF32 actualData = result->data.F64[i];
 
             if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) {
-                printf("TEST ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
-                       i, xData, actualData, expectData);
+                printf("TEST ERROR: Fitted data %d: (%.1f), expected was (%.1f)\n",
+                       i, actualData, expectData);
                 testStatus = false;
             } else {
                 if (VERBOSE) {
-                    printf("GOOD: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
-                           i, xData, actualData, expectData);
+                    printf("GOOD: Fitted data %d: (%.1f), expected was (%.1f)\n",
+                           i, actualData, expectData);
                 }
             }
         }
+        psFree(result);
     }
 
@@ -480,4 +373,9 @@
     psFree(t);
     psFree(f);
+    psFree(xTruth);
+    psFree(yTruth);
+    psFree(zTruth);
+    psFree(tTruth);
+    psFree(fTruth);
     psFree(fErr);
     psFree(stats);
@@ -505,5 +403,5 @@
     F64 tests: Chebyshev polys, clip fit
  *****************************************************************************/
-psS32 main()
+int main()
 {
     psBool testStatus = true;
@@ -611,4 +509,6 @@
     testStatus &= genericTest(TS00_MASK_S32 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F64 | TS00_T_F64 | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false);
 
+    printf("Status: %x\n", testStatus);
+
     printFooter(stdout, "psMinimize functions: 4D Polynomial Fitting Functions", "", testStatus);
 }