Index: trunk/psLib/src/dataManip/psFFT.c
===================================================================
--- trunk/psLib/src/dataManip/psFFT.c	(revision 828)
+++ trunk/psLib/src/dataManip/psFFT.c	(revision 831)
@@ -5,6 +5,6 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-06-02 03:02:48 $
+ *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-06-02 23:29:21 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -448,16 +448,16 @@
     numElements = in->n;
 
-    out = psVectorRecycle(out,PS_TYPE_C32,numElements);
+    out = psVectorRecycle(out, numElements, PS_TYPE_C32);
 
     if (type == PS_TYPE_F32) {
         // need to convert to complex
-        psC32* outVec = out->vec.cf;
-        psF32* inVec = in->vec.f;
+        psC32* outVec = out->data.C32;
+        psF32* inVec = in->data.F32;
         for (unsigned int i=0;i<numElements;i++) {
             outVec[i] = inVec[i];
         }
     } else {
-        psC32* outVec = out->vec.cf;
-        psC32* inVec = in->vec.cf;
+        psC32* outVec = out->data.C32;
+        psC32* inVec = in->data.C32;
         for (unsigned int i=0;i<numElements;i++) {
             outVec[i] = inVec[i];
@@ -466,6 +466,6 @@
 
     plan = fftwf_plan_dft_1d(numElements,
-                             (fftwf_complex*)out->vec.cf,
-                             (fftwf_complex*)out->vec.cf,
+                             (fftwf_complex*)out->data.C32,
+                             (fftwf_complex*)out->data.C32,
                              direction,
                              P_FFTW_PLAN_RIGOR);
@@ -504,6 +504,6 @@
         psLogMsg(__func__,PS_LOG_WARN,"Real portion of a non-Complex type called called for. "
                  "Just a vector copy was performed.");
-        out = psVectorRecycle(out,type,numElements);
-        memcpy(out->vec.v,in->vec.v,numElements*PSELEMTYPE_SIZEOF(type));
+        out = psVectorRecycle(out,numElements,type);
+        memcpy(out->data.V,in->data.V,numElements*PSELEMTYPE_SIZEOF(type));
         return out;
     }
@@ -511,8 +511,8 @@
     if (type == PS_TYPE_C32) {
         psF32* outVec;
-        psC32* inVec = in->vec.cf;
-
-        out = psVectorRecycle(out,PS_TYPE_F32,numElements);
-        outVec = out->vec.f;
+        psC32* inVec = in->data.C32;
+
+        out = psVectorRecycle(out,numElements,PS_TYPE_F32);
+        outVec = out->data.F32;
 
         for (unsigned int i=0;i<numElements;i++) {
@@ -548,5 +548,5 @@
                  "A zeroed vector was returned.");
         out = psVectorRecycle(out,numElements,type);
-        memset(out->vec.v,0,PSELEMTYPE_SIZEOF(type)*numElements);
+        memset(out->data.V,0,PSELEMTYPE_SIZEOF(type)*numElements);
         return out;
     }
@@ -554,8 +554,8 @@
     if (type == PS_TYPE_C32) {
         psF32* outVec;
-        psC32* inVec = in->vec.cf;
-
-        out = psVectorRecycle(out,PS_TYPE_F32,numElements);
-        outVec = out->vec.f;
+        psC32* inVec = in->data.C32;
+
+        out = psVectorRecycle(out,numElements, PS_TYPE_F32);
+        outVec = out->data.F32;
 
         for (unsigned int i=0;i<numElements;i++) {
@@ -601,9 +601,9 @@
     if (type == PS_TYPE_F32) {
         psC32* outVec;
-        psF32* realVec = real->vec.f;
-        psF32* imagVec = imag->vec.f;
-
-        out = psVectorRecycle(out,PS_TYPE_C32,numElements);
-        outVec = out->vec.cf;
+        psF32* realVec = real->data.F32;
+        psF32* imagVec = imag->data.F32;
+
+        out = psVectorRecycle(out,numElements, PS_TYPE_C32);
+        outVec = out->data.C32;
 
         for (unsigned int i=0;i<numElements;i++) {
@@ -639,6 +639,6 @@
                  "Vector copy was performed instead.");
 
-        out = psVectorRecycle(out,type,numElements);
-        memcpy(out->vec.v,in->vec.v,PSELEMTYPE_SIZEOF(type)*numElements);
+        out = psVectorRecycle(out,numElements,type);
+        memcpy(out->data.V,in->data.V,PSELEMTYPE_SIZEOF(type)*numElements);
         return out;
     }
@@ -646,8 +646,8 @@
     if (type == PS_TYPE_C32) {
         psC32* outVec;
-        psC32* inVec = in->vec.cf;
-
-        out = psVectorRecycle(out,PS_TYPE_C32,numElements);
-        outVec = out->vec.cf;
+        psC32* inVec = in->data.C32;
+
+        out = psVectorRecycle(out,numElements,PS_TYPE_C32);
+        outVec = out->data.C32;
 
         for (unsigned int i=0;i<numElements;i++) {
@@ -686,11 +686,11 @@
     if (type == PS_TYPE_C32) {
         psF32* outVec;
-        psC32* inVec = in->vec.cf;
+        psC32* inVec = in->data.C32;
         psF32 real;
         psF32 imag;
 
 
-        out = psVectorRecycle(out,PS_TYPE_F32,numElements);
-        outVec = out->vec.f;
+        out = psVectorRecycle(out,numElements,PS_TYPE_F32);
+        outVec = out->data.F32;
 
         for (unsigned int i=0;i<numElements;i++) {
Index: trunk/psLib/src/dataManip/psFunctions.c
===================================================================
--- trunk/psLib/src/dataManip/psFunctions.c	(revision 828)
+++ trunk/psLib/src/dataManip/psFunctions.c	(revision 831)
@@ -6,6 +6,6 @@
  *  @author George Gusciora, MHPCC
  *
- *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-06-01 22:24:55 $
+ *  @version $Revision: 1.9 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-06-02 23:29:21 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -75,5 +75,5 @@
     int i = 0;
 
-    gauss = psVectorAlloc(Npts, PS_TYPE_FLOAT);
+    gauss = psVectorAlloc(Npts, PS_TYPE_F32);
     gsl_rng_env_setup();
     T = gsl_rng_default;
@@ -81,5 +81,5 @@
 
     for (i = 0; i < Npts; i++) {
-        gauss->vec.f[i] = mean + gsl_ran_gaussian(r, sigma);
+        gauss->data.F32[i] = mean + gsl_ran_gaussian(r, sigma);
     }
 
Index: trunk/psLib/src/dataManip/psMatrix.c
===================================================================
--- trunk/psLib/src/dataManip/psMatrix.c	(revision 828)
+++ trunk/psLib/src/dataManip/psMatrix.c	(revision 831)
@@ -20,6 +20,6 @@
  *  @author Ross Harman, MHPCC
  *   
- *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-06-01 22:42:57 $
+ *  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-06-02 23:29:21 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -70,5 +70,5 @@
 /** Preprocessor macro to generate error a NULL image */
 #define PS_CHECK_NULL_VECTOR(NAME, RETURN)                                                          \
-if (NAME == NULL || NAME->vec.v == NULL) {                                                          \
+if (NAME == NULL || NAME->data.V == NULL) {                                                          \
     psError(__func__,"Invalid operation: %s or its data is NULL.", #NAME);                          \
     return RETURN;                                                                                  \
@@ -78,5 +78,5 @@
 #define PS_CHECK_ALLOC_VECTOR(NAME, SIZE, PS_TYPE)                                                  \
 if(NAME == NULL) {                                                                                  \
-    NAME = psVectorAlloc(PS_TYPE, SIZE);                                                            \
+    NAME = psVectorAlloc(SIZE, PS_TYPE);                                                            \
 }
 
@@ -173,5 +173,5 @@
     perm.size = numCols;
     outPerm->n = numCols;
-    perm.data = outPerm->vec.v;
+    perm.data = outPerm->data.V;
     PS_GSL_MATRIX_INITIALIZE(lu, outImage->data.V[0]);
 
@@ -226,13 +226,13 @@
 
     perm.size = inPerm->n;
-    perm.data = inPerm->vec.v;
+    perm.data = inPerm->data.V;
 
     b.size = inVector->n;
     b.stride = 1;
-    b.data = inVector->vec.v;
+    b.data = inVector->data.V;
 
     x.size = numCols;
     x.stride = 1;
-    x.data = outVector->vec.v;
+    x.data = outVector->data.V;
 
     // Solve for {x} in equation: {b} = [A]{x}
@@ -483,5 +483,5 @@
 
     colSize = PSELEMTYPE_SIZEOF(inImage->type.type)*inImage->numRows;
-    memcpy(outVector->vec.v, inImage->data.V[0], colSize);
+    memcpy(outVector->data.V, inImage->data.V[0], colSize);
 
     return outVector;
@@ -510,5 +510,5 @@
 
     colSize = PSELEMTYPE_SIZEOF(outImage->type.type)*outImage->numRows;
-    memcpy(outImage->data.V[0], inVector->vec.v, colSize);
+    memcpy(outImage->data.V[0], inVector->data.V, colSize);
 
     return outImage;
Index: trunk/psLib/src/dataManip/psStats.c
===================================================================
--- trunk/psLib/src/dataManip/psStats.c	(revision 828)
+++ trunk/psLib/src/dataManip/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");
         }
     }
Index: trunk/psLib/src/dataManip/psVectorFFT.c
===================================================================
--- trunk/psLib/src/dataManip/psVectorFFT.c	(revision 828)
+++ trunk/psLib/src/dataManip/psVectorFFT.c	(revision 831)
@@ -5,6 +5,6 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-06-02 03:02:48 $
+ *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-06-02 23:29:21 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -448,16 +448,16 @@
     numElements = in->n;
 
-    out = psVectorRecycle(out,PS_TYPE_C32,numElements);
+    out = psVectorRecycle(out, numElements, PS_TYPE_C32);
 
     if (type == PS_TYPE_F32) {
         // need to convert to complex
-        psC32* outVec = out->vec.cf;
-        psF32* inVec = in->vec.f;
+        psC32* outVec = out->data.C32;
+        psF32* inVec = in->data.F32;
         for (unsigned int i=0;i<numElements;i++) {
             outVec[i] = inVec[i];
         }
     } else {
-        psC32* outVec = out->vec.cf;
-        psC32* inVec = in->vec.cf;
+        psC32* outVec = out->data.C32;
+        psC32* inVec = in->data.C32;
         for (unsigned int i=0;i<numElements;i++) {
             outVec[i] = inVec[i];
@@ -466,6 +466,6 @@
 
     plan = fftwf_plan_dft_1d(numElements,
-                             (fftwf_complex*)out->vec.cf,
-                             (fftwf_complex*)out->vec.cf,
+                             (fftwf_complex*)out->data.C32,
+                             (fftwf_complex*)out->data.C32,
                              direction,
                              P_FFTW_PLAN_RIGOR);
@@ -504,6 +504,6 @@
         psLogMsg(__func__,PS_LOG_WARN,"Real portion of a non-Complex type called called for. "
                  "Just a vector copy was performed.");
-        out = psVectorRecycle(out,type,numElements);
-        memcpy(out->vec.v,in->vec.v,numElements*PSELEMTYPE_SIZEOF(type));
+        out = psVectorRecycle(out,numElements,type);
+        memcpy(out->data.V,in->data.V,numElements*PSELEMTYPE_SIZEOF(type));
         return out;
     }
@@ -511,8 +511,8 @@
     if (type == PS_TYPE_C32) {
         psF32* outVec;
-        psC32* inVec = in->vec.cf;
-
-        out = psVectorRecycle(out,PS_TYPE_F32,numElements);
-        outVec = out->vec.f;
+        psC32* inVec = in->data.C32;
+
+        out = psVectorRecycle(out,numElements,PS_TYPE_F32);
+        outVec = out->data.F32;
 
         for (unsigned int i=0;i<numElements;i++) {
@@ -548,5 +548,5 @@
                  "A zeroed vector was returned.");
         out = psVectorRecycle(out,numElements,type);
-        memset(out->vec.v,0,PSELEMTYPE_SIZEOF(type)*numElements);
+        memset(out->data.V,0,PSELEMTYPE_SIZEOF(type)*numElements);
         return out;
     }
@@ -554,8 +554,8 @@
     if (type == PS_TYPE_C32) {
         psF32* outVec;
-        psC32* inVec = in->vec.cf;
-
-        out = psVectorRecycle(out,PS_TYPE_F32,numElements);
-        outVec = out->vec.f;
+        psC32* inVec = in->data.C32;
+
+        out = psVectorRecycle(out,numElements, PS_TYPE_F32);
+        outVec = out->data.F32;
 
         for (unsigned int i=0;i<numElements;i++) {
@@ -601,9 +601,9 @@
     if (type == PS_TYPE_F32) {
         psC32* outVec;
-        psF32* realVec = real->vec.f;
-        psF32* imagVec = imag->vec.f;
-
-        out = psVectorRecycle(out,PS_TYPE_C32,numElements);
-        outVec = out->vec.cf;
+        psF32* realVec = real->data.F32;
+        psF32* imagVec = imag->data.F32;
+
+        out = psVectorRecycle(out,numElements, PS_TYPE_C32);
+        outVec = out->data.C32;
 
         for (unsigned int i=0;i<numElements;i++) {
@@ -639,6 +639,6 @@
                  "Vector copy was performed instead.");
 
-        out = psVectorRecycle(out,type,numElements);
-        memcpy(out->vec.v,in->vec.v,PSELEMTYPE_SIZEOF(type)*numElements);
+        out = psVectorRecycle(out,numElements,type);
+        memcpy(out->data.V,in->data.V,PSELEMTYPE_SIZEOF(type)*numElements);
         return out;
     }
@@ -646,8 +646,8 @@
     if (type == PS_TYPE_C32) {
         psC32* outVec;
-        psC32* inVec = in->vec.cf;
-
-        out = psVectorRecycle(out,PS_TYPE_C32,numElements);
-        outVec = out->vec.cf;
+        psC32* inVec = in->data.C32;
+
+        out = psVectorRecycle(out,numElements,PS_TYPE_C32);
+        outVec = out->data.C32;
 
         for (unsigned int i=0;i<numElements;i++) {
@@ -686,11 +686,11 @@
     if (type == PS_TYPE_C32) {
         psF32* outVec;
-        psC32* inVec = in->vec.cf;
+        psC32* inVec = in->data.C32;
         psF32 real;
         psF32 imag;
 
 
-        out = psVectorRecycle(out,PS_TYPE_F32,numElements);
-        outVec = out->vec.f;
+        out = psVectorRecycle(out,numElements,PS_TYPE_F32);
+        outVec = out->data.F32;
 
         for (unsigned int i=0;i<numElements;i++) {