Changeset 1233 for trunk/psLib/src/collections/psVector.c

Timestamp:

Jul 15, 2004, 1:52:34 PM (22 years ago)

Author:

desonia

Message:

Changed psSort and psSortIndex to psVectorSort and psVectorSortIndex as well as added support for all non-complex datatypes.

File:

• trunk/psLib/src/collections/psVector.c (modified) (3 diffs)

trunk/psLib/src/collections/psVector.c

@@ -8 +8 @@
  *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.13 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-07-15 22:18:02 $
+ *  @version $Revision: 1.14 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-07-15 23:52:33 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -17 +17 @@
 /*  INCLUDE FILES                                                             */
 /******************************************************************************/
+#include <string.h>        // for memcpy
+#include <stdlib.h>
+#include <math.h>
+
 #include "psMemory.h"
 #include "psError.h"
 #include "psVector.h"
 #include "psLogMsg.h"
+#include "psCompare.h"
 
 /******************************************************************************/
@@ -143 +148 @@
 }
 
+psVector *psVectorSort(psVector *restrict outVector, const psVector *restrict inVector)
+{
+    int inN = 0;
+    int outN = 0;
+    int elSize = 0;
+    void *inVec = NULL;
+    void *outVec = NULL;
+    psElemType inType = 0;
+
+    if(inVector == NULL) {
+        psError(__func__, " : Line %d - Null input vector\n", __LINE__);
+        return outVector;
+    }
+
+    inType = inVector->type.type;
+    inN = inVector->n;
+    inVec = inVector->data.V;
+    elSize = PSELEMTYPE_SIZEOF(inType);
+
+    if(outVector == NULL) {
+        outVector = psVectorAlloc(inN, inType);
+        outVector->n = inVector->n;
+    }
+
+    outN = outVector->n;
+    outVec = outVector->data.V;
+
+    if(inN != outN) {
+        psError(__func__, " : Line %d - Input and output vector sizes are not equal: in=%d out=%d\n", __LINE__,
+                inN, outN);
+        return outVector;
+    }
+
+    if(inN == 0) {
+        psError(__func__, " : Line %d - No elements in use for input vector\n", __LINE__);
+        return outVector;
+    }
+
+    if(outN == 0) {
+        psError(__func__, " : Line %d - No elements in use for output vector\n", __LINE__);
+        return outVector;
+    }
+
+    // Copy input vector values into output vector
+    memcpy(outVec, inVec, elSize*outN);
+
+    // Sort output vector
+    switch(inType) {
+    case PS_TYPE_U8:
+        qsort(outVec, inN, elSize, psCompareU8);
+        break;
+    case PS_TYPE_U16:
+        qsort(outVec, inN, elSize, psCompareU16);
+        break;
+    case PS_TYPE_U32:
+        qsort(outVec, inN, elSize, psCompareU32);
+        break;
+    case PS_TYPE_U64:
+        qsort(outVec, inN, elSize, psCompareU64);
+        break;
+    case PS_TYPE_S8:
+        qsort(outVec, inN, elSize, psCompareS8);
+        break;
+    case PS_TYPE_S16:
+        qsort(outVec, inN, elSize, psCompareS16);
+        break;
+    case PS_TYPE_S32:
+        qsort(outVec, inN, elSize, psCompareS32);
+        break;
+    case PS_TYPE_S64:
+        qsort(outVec, inN, elSize, psCompareS64);
+        break;
+    case PS_TYPE_F32:
+        qsort(outVec, inN, elSize, psCompareF32);
+        break;
+    case PS_TYPE_F64:
+        qsort(outVec, inN, elSize, psCompareF64);
+        break;
+    default:
+        psError(__func__, " : Line %d - Invalid psType\n", __LINE__);
+    }
+
+    return outVector;
+}
+
+#define SORT_INDICES(TYPE)                                                                                   \
+for(i=0; i<inN; i++) {                                                                                       \
+    for(j=0; j<inN; j++) {                                                                                   \
+        diff = fabs((double)tmpVector->data.TYPE[i] - inVec[j]);                                             \
+        if(diff < FLT_EPSILON) {                                                                             \
+            outVec[i] = j;                                                                                   \
+            break;                                                                                           \
+        }                                                                                                    \
+    }                                                                                                        \
+}
+
+psVector *psVectorSortIndex(psVector *restrict outVector, const psVector *restrict inVector)
+{
+    int inN = 0;
+    int outN = 0;
+    int i = 0;
+    int j = 0;
+    float *inVec = NULL;
+    int *outVec = NULL;
+    double diff = 0.0f;
+    psVector *tmpVector = NULL;
+    psElemType inType = 0;
+
+    if(inVector == NULL) {
+        psError(__func__, " : Line %d - Null input vector\n", __LINE__);
+        return outVector;
+    }
+
+    inN = inVector->n;
+    inVec = inVector->data.V;
+    inType = inVector->type.type;
+
+    if(outVector == NULL) {
+        outVector = psVectorAlloc(inN, PS_TYPE_U32);
+        outVector->n = inN;
+    }
+
+    outN = outVector->n;
+    outVec = outVector->data.V;
+
+    if(inN != outN) {
+        psError(__func__, " : Line %d - Input and output vector sizes are not equal: in=%d out=%d\n",
+                __LINE__, inN, outN);
+        return outVector;
+    }
+
+    tmpVector = psVectorAlloc(inN, inType);
+    tmpVector->n = inN;
+    tmpVector = psVectorSort(tmpVector, inVector);
+
+    // Sort output vector
+    switch(inType) {
+    case PS_TYPE_U8:
+        SORT_INDICES(U8);
+        break;
+    case PS_TYPE_U16:
+        SORT_INDICES(U16);
+        break;
+    case PS_TYPE_U32:
+        SORT_INDICES(U32);
+        break;
+    case PS_TYPE_U64:
+        SORT_INDICES(U64);
+        break;
+    case PS_TYPE_S8:
+        SORT_INDICES(S8);
+        break;
+    case PS_TYPE_S16:
+        SORT_INDICES(S16);
+        break;
+    case PS_TYPE_S32:
+        SORT_INDICES(S32);
+        break;
+    case PS_TYPE_S64:
+        SORT_INDICES(S64);
+        break;
+    case PS_TYPE_F32:
+        SORT_INDICES(F32);
+        break;
+    case PS_TYPE_F64:
+        SORT_INDICES(F64);
+        break;
+    default:
+        psError(__func__, " : Line %d - Invalid psType\n", __LINE__);
+    }
+
+    // Free temp memory
+    psFree(tmpVector);
+
+    return outVector;
+}
+
 static void vectorFree(psVector *restrict psVec)
 {