Index: trunk/psLib/src/math/psStats.c
===================================================================
--- trunk/psLib/src/math/psStats.c	(revision 797)
+++ trunk/psLib/src/math/psStats.c	(revision 831)
@@ -86,10 +86,10 @@
 
     newHist = (psHistogram *) psAlloc(sizeof(psHistogram));
-    newHist->bounds = psVectorAlloc(PS_TYPE_FLOAT, n+1);
+    newHist->bounds = psVectorAlloc(n+1, PS_TYPE_F32);
     binSize = (upper - lower) / (float) n;
     for (i=0;i<n+1;i++) {
-        newHist->bounds->vec.f[i] = lower + (binSize * (float) i);
-    }
-    newHist->nums =  psVectorAlloc(PS_TYPE_INT32, n);
+        newHist->bounds->data.F32[i] = lower + (binSize * (float) i);
+    }
+    newHist->nums =  psVectorAlloc(n, PS_TYPE_S32);
     newHist->minNum = 0;
     newHist->maxNum = 0;
@@ -106,9 +106,9 @@
 
     newHist = (psHistogram *) psAlloc(sizeof(psHistogram));
-    newHist->bounds = psVectorAlloc(PS_TYPE_FLOAT, bounds->n);
+    newHist->bounds = psVectorAlloc(bounds->n, PS_TYPE_F32);
     for (i=0;i<bounds->n;i++) {
-        newHist->bounds->vec.f[i] = bounds->vec.f[i];
-    }
-    newHist->nums = psVectorAlloc(PS_TYPE_INT32, (bounds->n)-1);
+        newHist->bounds->data.F32[i] = bounds->data.F32[i];
+    }
+    newHist->nums = psVectorAlloc((bounds->n)-1, PS_TYPE_S32);
 
     newHist->minNum = 0;
@@ -152,13 +152,13 @@
     for (i=0;i<in->n;i++) {
         // Check if this pixel is masked, and if so, skip it.
-        if (!(mask->vec.i32[i] & maskVal)) {
+        if (!(mask->data.S32[i] & maskVal)) {
             // Check if this pixel is below the minimum value, and if so
             // count it, then skip it.
-            if (in->vec.f[i] < out->bounds->vec.f[0]) {
+            if (in->data.F32[i] < out->bounds->data.F32[0]) {
                 out->minNum++;
 
                 // Check if this pixel is above the maximum value, and if so
                 // count it, then skip it.
-            } else if (in->vec.f[i] > out->bounds->vec.f[numBins]) {
+            } else if (in->data.F32[i] > out->bounds->data.F32[numBins]) {
                 out->maxNum++;
             } else {
@@ -166,9 +166,9 @@
                 // number is trivial.
                 if (out->uniform == true) {
-                    binSize = out->bounds->vec.f[1] - out->bounds->vec.f[0];
-
-                    binNum = (int) ((in->vec.f[i] - out->bounds->vec.f[0]) /
+                    binSize = out->bounds->data.F32[1] - out->bounds->data.F32[0];
+
+                    binNum = (int) ((in->data.F32[i] - out->bounds->data.F32[0]) /
                                     binSize);
-                    (out->nums->vec.i32[binNum])++;
+                    (out->nums->data.S32[binNum])++;
                     // If this is a non-uniform histogram, determining the correct
                     // bin number requires a bit more work.
@@ -177,7 +177,7 @@
                     // find the correct bin number (bin search, probably)
                     for (j=0;j<(out->bounds->n)-1;j++) {
-                        if ((out->bounds->vec.i32[j] <= in->vec.f[i]) &&
-                                (in->vec.f[i] <= out->bounds->vec.i32[j+1])) {
-                            (out->nums->vec.i32[j])++;
+                        if ((out->bounds->data.S32[j] <= in->data.F32[i]) &&
+                                (in->data.F32[i] <= out->bounds->data.S32[j+1])) {
+                            (out->nums->data.S32[j])++;
                         }
                     }
@@ -198,7 +198,7 @@
     for (i=0;i<myVector->n;i++) {
         if (maskVector != NULL)
-            printf("Element %d is %f (mask is %d)\n", i, myVector->vec.f[i], maskVector->vec.ui8[i]);
+            printf("Element %d is %f (mask is %d)\n", i, myVector->data.F32[i], maskVector->data.U8[i]);
         else
-            printf("Element %d is %f\n", i, myVector->vec.f[i]);
+            printf("Element %d is %f\n", i, myVector->data.F32[i]);
     }
 }
@@ -234,8 +234,8 @@
         if (maskVector != NULL) {
             for (i=0;i<myVector->n;i++) {
-                if (!(maskVal & maskVector->vec.ui8[i]) &&
-                        (rangeMin <= myVector->vec.f[i]) &&
-                        (myVector->vec.f[i] <= rangeMax)) {
-                    mean+= myVector->vec.f[i];
+                if (!(maskVal & maskVector->data.U8[i]) &&
+                        (rangeMin <= myVector->data.F32[i]) &&
+                        (myVector->data.F32[i] <= rangeMax)) {
+                    mean+= myVector->data.F32[i];
                     count++;
                 }
@@ -244,7 +244,7 @@
         } else {
             for (i=0;i<myVector->n;i++) {
-                if ((rangeMin <= myVector->vec.f[i]) &&
-                        (myVector->vec.f[i] <= rangeMax)) {
-                    mean+= myVector->vec.f[i];
+                if ((rangeMin <= myVector->data.F32[i]) &&
+                        (myVector->data.F32[i] <= rangeMax)) {
+                    mean+= myVector->data.F32[i];
                     count++;
                 }
@@ -255,6 +255,6 @@
         if (maskVector != NULL) {
             for (i=0;i<myVector->n;i++) {
-                if (!(maskVal & maskVector->vec.ui8[i])) {
-                    mean+= myVector->vec.f[i];
+                if (!(maskVal & maskVector->data.U8[i])) {
+                    mean+= myVector->data.F32[i];
                     count++;
                 }
@@ -263,5 +263,5 @@
         } else {
             for (i=0;i<myVector->n;i++) {
-                mean+= myVector->vec.f[i];
+                mean+= myVector->data.F32[i];
             }
             mean/= (float) myVector->n;
@@ -287,9 +287,9 @@
         if (maskVector != NULL) {
             for (i=0;i<myVector->n;i++) {
-                if (!(maskVal & maskVector->vec.ui8[i])) {
-                    if ((myVector->vec.f[i] > max) &&
-                            (rangeMin <= myVector->vec.f[i]) &&
-                            (myVector->vec.f[i] <= rangeMax)) {
-                        max = myVector->vec.f[i];
+                if (!(maskVal & maskVector->data.U8[i])) {
+                    if ((myVector->data.F32[i] > max) &&
+                            (rangeMin <= myVector->data.F32[i]) &&
+                            (myVector->data.F32[i] <= rangeMax)) {
+                        max = myVector->data.F32[i];
                     }
                 }
@@ -297,8 +297,8 @@
         } else {
             for (i=0;i<myVector->n;i++) {
-                if ((myVector->vec.f[i] > max) &&
-                        (rangeMin <= myVector->vec.f[i]) &&
-                        (myVector->vec.f[i] <= rangeMax)) {
-                    max = myVector->vec.f[i];
+                if ((myVector->data.F32[i] > max) &&
+                        (rangeMin <= myVector->data.F32[i]) &&
+                        (myVector->data.F32[i] <= rangeMax)) {
+                    max = myVector->data.F32[i];
                 }
             }
@@ -307,7 +307,7 @@
         if (maskVector != NULL) {
             for (i=0;i<myVector->n;i++) {
-                if (!(maskVal & maskVector->vec.ui8[i])) {
-                    if (myVector->vec.f[i] > max) {
-                        max = myVector->vec.f[i];
+                if (!(maskVal & maskVector->data.U8[i])) {
+                    if (myVector->data.F32[i] > max) {
+                        max = myVector->data.F32[i];
                     }
                 }
@@ -315,6 +315,6 @@
         } else {
             for (i=0;i<myVector->n;i++) {
-                if (myVector->vec.f[i] > max) {
-                    max = myVector->vec.f[i];
+                if (myVector->data.F32[i] > max) {
+                    max = myVector->data.F32[i];
                 }
             }
@@ -340,9 +340,9 @@
         if (maskVector != NULL) {
             for (i=0;i<myVector->n;i++) {
-                if (!(maskVal & maskVector->vec.ui8[i])) {
-                    if ((myVector->vec.f[i] < min) &&
-                            (rangeMin <= myVector->vec.f[i]) &&
-                            (myVector->vec.f[i] <= rangeMax)) {
-                        min = myVector->vec.f[i];
+                if (!(maskVal & maskVector->data.U8[i])) {
+                    if ((myVector->data.F32[i] < min) &&
+                            (rangeMin <= myVector->data.F32[i]) &&
+                            (myVector->data.F32[i] <= rangeMax)) {
+                        min = myVector->data.F32[i];
                     }
                 }
@@ -350,8 +350,8 @@
         } else {
             for (i=0;i<myVector->n;i++) {
-                if ((myVector->vec.f[i] < min) &&
-                        (rangeMin <= myVector->vec.f[i]) &&
-                        (myVector->vec.f[i] <= rangeMax)) {
-                    min = myVector->vec.f[i];
+                if ((myVector->data.F32[i] < min) &&
+                        (rangeMin <= myVector->data.F32[i]) &&
+                        (myVector->data.F32[i] <= rangeMax)) {
+                    min = myVector->data.F32[i];
                 }
             }
@@ -360,7 +360,7 @@
         if (maskVector != NULL) {
             for (i=0;i<myVector->n;i++) {
-                if (!(maskVal & maskVector->vec.ui8[i])) {
-                    if (myVector->vec.f[i] < min) {
-                        min = myVector->vec.f[i];
+                if (!(maskVal & maskVector->data.U8[i])) {
+                    if (myVector->data.F32[i] < min) {
+                        min = myVector->data.F32[i];
                     }
                 }
@@ -368,6 +368,6 @@
         } else {
             for (i=0;i<myVector->n;i++) {
-                if (myVector->vec.f[i] < min) {
-                    min = myVector->vec.f[i];
+                if (myVector->data.F32[i] < min) {
+                    min = myVector->data.F32[i];
                 }
             }
@@ -397,7 +397,7 @@
         if (maskVector != NULL) {
             for (i=0;i<myVector->n;i++) {
-                if (!(maskVal & maskVector->vec.ui8[i]) &&
-                        (rangeMin <= myVector->vec.f[i]) &&
-                        (myVector->vec.f[i] <= rangeMax)) {
+                if (!(maskVal & maskVector->data.U8[i]) &&
+                        (rangeMin <= myVector->data.F32[i]) &&
+                        (myVector->data.F32[i] <= rangeMax)) {
                     numData++;
                 }
@@ -405,6 +405,6 @@
         } else {
             for (i=0;i<myVector->n;i++) {
-                if ((rangeMin <= myVector->vec.f[i]) &&
-                        (myVector->vec.f[i] <= rangeMax)) {
+                if ((rangeMin <= myVector->data.F32[i]) &&
+                        (myVector->data.F32[i] <= rangeMax)) {
                     numData++;
                 }
@@ -416,5 +416,5 @@
         if (maskVector != NULL) {
             for (i=0;i<myVector->n;i++) {
-                if (!(maskVal & maskVector->vec.ui8[i])) {
+                if (!(maskVal & maskVector->data.U8[i])) {
                     numData++;
                 }
@@ -469,7 +469,7 @@
 
     // Allocate temporary vectors for the data.
-    unsortedVector = psVectorAlloc(PS_TYPE_FLOAT, nValues);
+    unsortedVector = psVectorAlloc(nValues, PS_TYPE_F32);
     unsortedVector->n = unsortedVector->nalloc;
-    sortedVector   = psVectorAlloc(PS_TYPE_FLOAT, nValues);
+    sortedVector   = psVectorAlloc(nValues, PS_TYPE_F32);
     sortedVector->n = sortedVector->nalloc;
 
@@ -484,15 +484,15 @@
         if (maskVector != NULL) {
             for (i=0;i<myVector->n;i++) {
-                if (!(maskVal & maskVector->vec.ui8[i]) &&
-                        (rangeMin <= myVector->vec.f[i]) &&
-                        (myVector->vec.f[i] <= rangeMax)) {
-                    unsortedVector->vec.f[count++] = maskVector->vec.f[i];
-                }
-            }
-        } else {
-            for (i=0;i<myVector->n;i++) {
-                if ((rangeMin <= myVector->vec.f[i]) &&
-                        (myVector->vec.f[i] <= rangeMax)) {
-                    unsortedVector->vec.f[count++] = maskVector->vec.f[i];
+                if (!(maskVal & maskVector->data.U8[i]) &&
+                        (rangeMin <= myVector->data.F32[i]) &&
+                        (myVector->data.F32[i] <= rangeMax)) {
+                    unsortedVector->data.F32[count++] = maskVector->data.F32[i];
+                }
+            }
+        } else {
+            for (i=0;i<myVector->n;i++) {
+                if ((rangeMin <= myVector->data.F32[i]) &&
+                        (myVector->data.F32[i] <= rangeMax)) {
+                    unsortedVector->data.F32[count++] = maskVector->data.F32[i];
                 }
             }
@@ -503,11 +503,11 @@
         if (maskVector != NULL) {
             for (i=0;i<myVector->n;i++) {
-                if (!(maskVal & maskVector->vec.ui8[i])) {
-                    unsortedVector->vec.f[count++] = maskVector->vec.f[i];
-                }
-            }
-        } else {
-            for (i=0;i<myVector->n;i++) {
-                unsortedVector->vec.f[i] = maskVector->vec.f[i];
+                if (!(maskVal & maskVector->data.U8[i])) {
+                    unsortedVector->data.F32[count++] = maskVector->data.F32[i];
+                }
+            }
+        } else {
+            for (i=0;i<myVector->n;i++) {
+                unsortedVector->data.F32[i] = maskVector->data.F32[i];
             }
         }
@@ -518,8 +518,8 @@
     // Calculate the median exactly.
     if (0 == (nValues % 2)) {
-        stats->sampleMedian = 0.5 * (sortedVector->vec.f[(nValues/2)-1] +
-                                     sortedVector->vec.f[nValues/2]);
+        stats->sampleMedian = 0.5 * (sortedVector->data.F32[(nValues/2)-1] +
+                                     sortedVector->data.F32[nValues/2]);
     } else {
-        stats->sampleMedian = sortedVector->vec.f[nValues/2];
+        stats->sampleMedian = sortedVector->data.F32[nValues/2];
     }
 
@@ -569,7 +569,7 @@
         for (j=-GAUSS_WIDTH;j<=+GAUSS_WIDTH;j++) {
             if (((j+i) >= 0) && ((j+i) < robustHistogram->nums->n)) {
-                robustHistogram->nums->vec.i32[j+i]+=
+                robustHistogram->nums->data.S32[j+i]+=
                     (gaussianCoefs[j+GAUSS_WIDTH] *
-                     (float) robustHistogram->nums->vec.i32[j+i]);
+                     (float) robustHistogram->nums->data.S32[j+i]);
             }
         }
@@ -623,7 +623,7 @@
 
     // Allocate temporary vectors for the data.
-    unsortedVector = psVectorAlloc(PS_TYPE_FLOAT, nValues);
+    unsortedVector = psVectorAlloc(nValues, PS_TYPE_F32);
     unsortedVector->n = unsortedVector->nalloc;
-    sortedVector   = psVectorAlloc(PS_TYPE_FLOAT, nValues);
+    sortedVector   = psVectorAlloc(nValues, PS_TYPE_F32);
     sortedVector->n = sortedVector->nalloc;
 
@@ -637,15 +637,15 @@
         if (maskVector != NULL) {
             for (i=0;i<myVector->n;i++) {
-                if (!(maskVal & maskVector->vec.ui8[i]) &&
-                        (rangeMin <= myVector->vec.f[i]) &&
-                        (myVector->vec.f[i] <= rangeMax)) {
-                    unsortedVector->vec.f[count++] = maskVector->vec.f[i];
-                }
-            }
-        } else {
-            for (i=0;i<myVector->n;i++) {
-                if ((rangeMin <= myVector->vec.f[i]) &&
-                        (myVector->vec.f[i] <= rangeMax)) {
-                    unsortedVector->vec.f[count++] = maskVector->vec.f[i];
+                if (!(maskVal & maskVector->data.U8[i]) &&
+                        (rangeMin <= myVector->data.F32[i]) &&
+                        (myVector->data.F32[i] <= rangeMax)) {
+                    unsortedVector->data.F32[count++] = maskVector->data.F32[i];
+                }
+            }
+        } else {
+            for (i=0;i<myVector->n;i++) {
+                if ((rangeMin <= myVector->data.F32[i]) &&
+                        (myVector->data.F32[i] <= rangeMax)) {
+                    unsortedVector->data.F32[count++] = maskVector->data.F32[i];
                 }
             }
@@ -656,11 +656,11 @@
         if (maskVector != NULL) {
             for (i=0;i<myVector->n;i++) {
-                if (!(maskVal & maskVector->vec.ui8[i])) {
-                    unsortedVector->vec.f[count++] = maskVector->vec.f[i];
-                }
-            }
-        } else {
-            for (i=0;i<myVector->n;i++) {
-                unsortedVector->vec.f[i] = maskVector->vec.f[i];
+                if (!(maskVal & maskVector->data.U8[i])) {
+                    unsortedVector->data.F32[count++] = maskVector->data.F32[i];
+                }
+            }
+        } else {
+            for (i=0;i<myVector->n;i++) {
+                unsortedVector->data.F32[i] = maskVector->data.F32[i];
             }
         }
@@ -672,7 +672,7 @@
     // Calculate the quartile points exactly.
     ind = 3 * (nValues / 4);
-    stats->sampleUQ = sortedVector->vec.f[ind];
+    stats->sampleUQ = sortedVector->data.F32[ind];
     ind = (nValues / 4);
-    stats->sampleLQ = sortedVector->vec.f[ind];
+    stats->sampleLQ = sortedVector->data.F32[ind];
 
     // Free the temporary data structures.
@@ -765,11 +765,11 @@
     UQBinNum = -1;
     for (i=0;i<robustHistogram->nums->n;i++) {
-        if ((robustHistogram->nums->vec.i32[i] <= stats->sampleLQ) &&
-                (stats->sampleLQ <= robustHistogram->nums->vec.i32[i])) {
+        if ((robustHistogram->nums->data.S32[i] <= stats->sampleLQ) &&
+                (stats->sampleLQ <= robustHistogram->nums->data.S32[i])) {
             LQBinNum = i;
         }
 
-        if ((robustHistogram->nums->vec.i32[i] <= stats->sampleUQ) &&
-                (stats->sampleUQ <= robustHistogram->nums->vec.i32[i])) {
+        if ((robustHistogram->nums->data.S32[i] <= stats->sampleUQ) &&
+                (stats->sampleUQ <= robustHistogram->nums->data.S32[i])) {
             UQBinNum = i;
         }
@@ -778,9 +778,9 @@
     // Determine the bin with the peak value in the range LQ to UQ.
     maxBinNum = LQBinNum;
-    maxBinCount = robustHistogram->nums->vec.i32[maxBinNum];
+    maxBinCount = robustHistogram->nums->data.S32[maxBinNum];
     for (i=LQBinNum;i<=UQBinNum;i++) {
-        if (robustHistogram->nums->vec.i32[i] > maxBinCount) {
+        if (robustHistogram->nums->data.S32[i] > maxBinCount) {
             maxBinNum = i;
-            maxBinCount = robustHistogram->nums->vec.i32[i];
+            maxBinCount = robustHistogram->nums->data.S32[i];
         }
     }
@@ -843,8 +843,8 @@
         if (maskVector != NULL) {
             for (i=0;i<myVector->n;i++) {
-                if (!(maskVal & maskVector->vec.ui8[i]) &&
-                        (rangeMin <= myVector->vec.f[i]) &&
-                        (myVector->vec.f[i] <= rangeMax)) {
-                    diff = myVector->vec.f[i] - mean;
+                if (!(maskVal & maskVector->data.U8[i]) &&
+                        (rangeMin <= myVector->data.F32[i]) &&
+                        (myVector->data.F32[i] <= rangeMax)) {
+                    diff = myVector->data.F32[i] - mean;
                     sumSquares+= (diff * diff);
                     sumDiffs+= diff;
@@ -854,7 +854,7 @@
         } else {
             for (i=0;i<myVector->n;i++) {
-                if ((rangeMin <= myVector->vec.f[i]) &&
-                        (myVector->vec.f[i] <= rangeMax)) {
-                    diff = myVector->vec.f[i] - mean;
+                if ((rangeMin <= myVector->data.F32[i]) &&
+                        (myVector->data.F32[i] <= rangeMax)) {
+                    diff = myVector->data.F32[i] - mean;
                     sumSquares+= (diff * diff);
                     sumDiffs+= diff;
@@ -867,6 +867,6 @@
         if (maskVector != NULL) {
             for (i=0;i<myVector->n;i++) {
-                if (!(maskVal & maskVector->vec.ui8[i])) {
-                    diff = myVector->vec.f[i] - mean;
+                if (!(maskVal & maskVector->data.U8[i])) {
+                    diff = myVector->data.F32[i] - mean;
                     sumSquares+= (diff * diff);
                     sumDiffs+= diff;
@@ -876,5 +876,5 @@
         } else {
             for (i=0;i<myVector->n;i++) {
-                diff = myVector->vec.f[i] - mean;
+                diff = myVector->data.F32[i] - mean;
                 sumSquares+= (diff * diff);
                 sumDiffs+= diff;
@@ -920,9 +920,9 @@
     }
 
-    tmpMask = psVectorAlloc(maskVector->type.type, myVector->nalloc);
+    tmpMask = psVectorAlloc(myVector->nalloc, maskVector->type.type);
 
     tmpMask->n = maskVector->n;
     for (i=0;i<tmpMask->n;i++) {
-        tmpMask->vec.ui8[i] = maskVector->vec.ui8[i];
+        tmpMask->data.U8[i] = maskVector->data.U8[i];
     }
 
@@ -944,7 +944,7 @@
         for (j=0;j<myVector->n;j++) {
             // a) Exclude all values x_i for which |x_i - x| > K * stdev
-            if ( fabs(myVector->vec.f[j] - clippedMean) >
+            if ( fabs(myVector->data.F32[j] - clippedMean) >
                     (stats->clipSigma * clippedStdev)) {
-                tmpMask->vec.ui8[i] = 0xff;
+                tmpMask->data.U8[i] = 0xff;
             }
             // b) compute new mean and stdev
@@ -979,6 +979,6 @@
  
     NOTE: The current strategy is to implement everything assuming that all
-    input data is of type PS_TYPE_FLOAT.  Once the basic code is in place,
-    we will macro-ize everything and add PS_TYPE_UINT16 and PS_TYPE_DOUBLE.
+    input data is of type PS_TYPE_F32.  Once the basic code is in place,
+    we will macro-ize everything and add PS_TYPE_U16 and PS_TYPE_F64.
  
  *****************************************************************************/
@@ -992,7 +992,7 @@
     }
 
-    if (in->type.type != PS_TYPE_FLOAT) {
+    if (in->type.type != PS_TYPE_F32) {
         psAbort(__func__,
-                "Only data type PS_TYPE_FLOAT is currently supported.");
+                "Only data type PS_TYPE_F32 is currently supported.");
     }
     if (mask != NULL) {
@@ -1001,7 +1001,7 @@
                     "Vector data and vector mask are of different sizes.");
         }
-        if (mask->type.type != PS_TYPE_UINT8) {
+        if (mask->type.type != PS_TYPE_U8) {
             psAbort(__func__,
-                    "Vector mask must be type PS_TYPE_UINT8");
+                    "Vector mask must be type PS_TYPE_U8");
         }
     }