Changeset 724 for trunk/psLib/src/math/psStats.c

Timestamp:

May 18, 2004, 2:17:14 PM (22 years ago)

Author:

desonia

Message:

added a ifdef to use sqrt instead of sqrtf for OS/X machines.

File:

• trunk/psLib/src/math/psStats.c (modified) (1 diff)

trunk/psLib/src/math/psStats.c

@@ -385 +385 @@
     }
     countFloat = (float) countInt;
-    newStruct->sampleStdev = sqrtf( (sumSquares-(sumDiffs *
-                                     sumDiffs/countFloat))/ (countFloat-1));
-}
-
-/******************************************************************************
- *****************************************************************************/
-void p_psArraySampleQuartiles(const psVector *restrict myVector,
-                              const psVector *restrict maskVector,
-                              unsigned int maskVal,
-                              psStats *newStruct)
-{
-    psVector *unsortedVector = NULL;
-    psVector *sortedVector = NULL;
-    int count = 0;
-    int ind = 0;
-    int i = 0;
-
-    // return is we have already calculated both quartile points.
-    if ((!isnan(newStruct->sampleLQ)) &&
-            (!isnan(newStruct->sampleUQ))) {
-        return;
-    }
-
-    if (-1 == newStruct->nValues) {
-        p_psArrayNValues(myVector, maskVector, maskVal, newStruct);
-    }
-
-
-    unsortedVector = psVectorAlloc(PS_TYPE_FLOAT, newStruct->nValues);
-    sortedVector   = psVectorAlloc(PS_TYPE_FLOAT, newStruct->nValues);
-
-    count = 0;
-    if (maskVector != NULL) {
-        for (i=0;i<myVector->n;i++) {
-            if (!(maskVal & maskVector->vec.ui8[i])) {
-                unsortedVector->vec.f[count++] = maskVector->vec.f[i];
-            }
-        }
-        psSort(sortedVector, unsortedVector);
-    } else {
-        psSort(sortedVector, myVector);
-    }
-
-    ind = 3 * (newStruct->nValues / 4);
-    newStruct->sampleUQ = sortedVector->vec.f[ind];
-    ind = (newStruct->nValues / 4);
-    newStruct->sampleLQ = sortedVector->vec.f[ind];
-
-    psVectorFree(unsortedVector);
-    psVectorFree(sortedVector);
-}
-
-/******************************************************************************
- 
-    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.
- 
- *****************************************************************************/
-psStats *psArrayStats(const psVector *restrict myVector,
-                      const psVector *restrict maskVector,
-                      unsigned int maskVal,
-                      psStats *stats)
-{
-    psStats *newStruct = NULL;
-
-    if (myVector == NULL) {
-        psAbort(__func__,
-                "Input data array (myVector) was NULL.");
-    }
-
-    if (myVector->type.type != PS_TYPE_FLOAT) {
-        psAbort(__func__,
-                "Only data type PS_TYPE_FLOAT is currently supported.");
-    }
-
-    if (maskVector != NULL) {
-        if (myVector->n != maskVector->n) {
-            psAbort(__func__,
-                    "Vector data and vector mask are of different sizes.");
-        }
-        if (maskVector->type.type != PS_TYPE_UINT8) {
-            psAbort(__func__,
-                    "Vector mask must be type PS_TYPE_UINT8");
-        }
-    }
-    newStruct = psStatsAlloc(stats->options);
-
-    // ************************************************************************
-    if (stats->options & PS_STAT_SAMPLE_MEAN) {
-        p_psArraySampleMean(myVector, maskVector, maskVal, newStruct);
-    }
-
-    // ************************************************************************
-    if (stats->options & PS_STAT_MAX) {
-        p_psArrayMax(myVector, maskVector, maskVal, newStruct);
-    }
-
-    // ************************************************************************
-    if (stats->options & PS_STAT_MIN) {
-        p_psArrayMin(myVector, maskVector, maskVal, newStruct);
-    }
-
-    // ************************************************************************
-    if (stats->options & PS_STAT_NVALUES) {
-        p_psArrayNValues(myVector, maskVector, maskVal, newStruct);
-    }
-
-    // ************************************************************************
-    if (stats->options & PS_STAT_SAMPLE_MEDIAN) {
-        p_psArraySampleMedian(myVector, maskVector, maskVal, newStruct);
-    }
-
-    // ************************************************************************
-    if (stats->options & PS_STAT_SAMPLE_STDEV) {
-        p_psArraySampleStdev(myVector, maskVector, maskVal, newStruct);
-    }
-
-    // ************************************************************************
-    if ((stats->options & PS_STAT_SAMPLE_UQ) ||
-            (stats->options & PS_STAT_SAMPLE_LQ)) {
-        p_psArraySampleQuartiles(myVector, maskVector, maskVal, newStruct);
-    }
-
-
-
-
-    if (stats->options & PS_STAT_ROBUST_MEAN) {
-        newStruct->robustMean = p_psArrayXXX(myVector, maskVector, maskVal);
-    }
-
-    if (stats->options & PS_STAT_ROBUST_MEAN_NVALUES) {
-        newStruct->robustMeanNvalues = p_psArrayXXX(myVector, maskVector, maskVal);
-    }
-
-    if (stats->options & PS_STAT_ROBUST_MEDIAN) {
-        newStruct->robustMedian = p_psArrayXXX(myVector, maskVector, maskVal);
-    }
-
-    if (stats->options & PS_STAT_ROBUST_MEDIAN_NVALUES) {
-        newStruct->robustMedianNvalues = p_psArrayXXX(myVector, maskVector, maskVal);
-    }
-
-    if (stats->options & PS_STAT_ROBUST_MODE) {
-        newStruct->robustMode = p_psArrayXXX(myVector, maskVector, maskVal);
-    }
-
-    if (stats->options & PS_STAT_ROBUST_MODE_NVALUES) {
-        newStruct->robustModeNvalues = p_psArrayXXX(myVector, maskVector, maskVal);
-    }
-
-    if (stats->options & PS_STAT_ROBUST_STDEV) {
-        newStruct->robustStdev = p_psArrayXXX(myVector, maskVector, maskVal);
-    }
-
-    if ((stats->options & PS_STAT_ROBUST_UQ) ||
-            (stats->options & PS_STAT_ROBUST_LQ)) {
-        newStruct->robustLQ = p_psArrayXXX(myVector, maskVector, maskVal);
-    }
-
-    if (stats->options & PS_STAT_CLIPPED_MEAN) {
-        newStruct->clippedMean = p_psArrayXXX(myVector, maskVector, maskVal);
-    }
-
-    if (stats->options & PS_STAT_CLIPPED_MEAN_NVALUES) {
-        newStruct->clippedMeanNvalues = p_psArrayXXX(myVector, maskVector, maskVal);
-    }
-
-    if (stats->options & PS_STAT_CLIPPED_MEAN_NSIGMA) {
-        newStruct->clipSigma = p_psArrayXXX(myVector, maskVector, maskVal);
-    }
-
-    if (stats->options & PS_STAT_CLIPPED_STDEV) {
-        newStruct->clippedStdev = p_psArrayXXX(myVector, maskVector, maskVal);
-    }
-
-
-    //    OLD CODE: Should we check for an unknown option?
-    //    default:
-    //        psAbort(__func__, "Unknown options 0x%x.\n", stats->options);
-
-    return(newStruct);
-}
+    #ifdef DARWIN
+
+    newStruct->sampleStdev = sqrt(
+                                 #else
+                                 newStruct->sampleStdev = sqrtf(
+                                                              #endif
+                                                              (sumSquares-(sumDiffs * sumDiffs/countFloat))/ (countFloat-1));
+                             }
+
+                             /******************************************************************************
+                              *****************************************************************************/
+                             void p_psArraySampleQuartiles(const psVector *restrict myVector,
+                                                           const psVector *restrict maskVector,
+                                                           unsigned int maskVal,
+                                                           psStats *newStruct)
+                             {
+                                 psVector *unsortedVector = NULL;
+                                 psVector *sortedVector = NULL;
+                                 int count = 0;
+                                 int ind = 0;
+                                 int i = 0;
+
+                                 // return is we have already calculated both quartile points.
+                                 if ((!isnan(newStruct->sampleLQ)) &&
+                                         (!isnan(newStruct->sampleUQ))) {
+                                     return;
+                                 }
+
+                                 if (-1 == newStruct->nValues) {
+                                     p_psArrayNValues(myVector, maskVector, maskVal, newStruct);
+                                 }
+
+
+                                 unsortedVector = psVectorAlloc(PS_TYPE_FLOAT, newStruct->nValues);
+                                 sortedVector   = psVectorAlloc(PS_TYPE_FLOAT, newStruct->nValues);
+
+                                 count = 0;
+                                 if (maskVector != NULL) {
+                                     for (i=0;i<myVector->n;i++) {
+                                         if (!(maskVal & maskVector->vec.ui8[i])) {
+                                             unsortedVector->vec.f[count++] = maskVector->vec.f[i];
+                                         }
+                                     }
+                                     psSort(sortedVector, unsortedVector);
+                                 } else {
+                                     psSort(sortedVector, myVector);
+                                 }
+
+                                 ind = 3 * (newStruct->nValues / 4);
+                                 newStruct->sampleUQ = sortedVector->vec.f[ind];
+                                 ind = (newStruct->nValues / 4);
+                                 newStruct->sampleLQ = sortedVector->vec.f[ind];
+
+                                 psVectorFree(unsortedVector);
+                                 psVectorFree(sortedVector);
+                             }
+
+                             /******************************************************************************
+                              
+                                 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.
+                              
+                              *****************************************************************************/
+                             psStats *psArrayStats(const psVector *restrict myVector,
+                                                   const psVector *restrict maskVector,
+                                                   unsigned int maskVal,
+                                                   psStats *stats)
+                             {
+                                 psStats *newStruct = NULL;
+
+                                 if (myVector == NULL) {
+                                     psAbort(__func__,
+                                             "Input data array (myVector) was NULL.");
+                                 }
+
+                                 if (myVector->type.type != PS_TYPE_FLOAT) {
+                                     psAbort(__func__,
+                                             "Only data type PS_TYPE_FLOAT is currently supported.");
+                                 }
+
+                                 if (maskVector != NULL) {
+                                     if (myVector->n != maskVector->n) {
+                                         psAbort(__func__,
+                                                 "Vector data and vector mask are of different sizes.");
+                                     }
+                                     if (maskVector->type.type != PS_TYPE_UINT8) {
+                                         psAbort(__func__,
+                                                 "Vector mask must be type PS_TYPE_UINT8");
+                                     }
+                                 }
+                                 newStruct = psStatsAlloc(stats->options);
+
+                                 // ************************************************************************
+                                 if (stats->options & PS_STAT_SAMPLE_MEAN) {
+                                     p_psArraySampleMean(myVector, maskVector, maskVal, newStruct);
+                                 }
+
+                                 // ************************************************************************
+                                 if (stats->options & PS_STAT_MAX) {
+                                     p_psArrayMax(myVector, maskVector, maskVal, newStruct);
+                                 }
+
+                                 // ************************************************************************
+                                 if (stats->options & PS_STAT_MIN) {
+                                     p_psArrayMin(myVector, maskVector, maskVal, newStruct);
+                                 }
+
+                                 // ************************************************************************
+                                 if (stats->options & PS_STAT_NVALUES) {
+                                     p_psArrayNValues(myVector, maskVector, maskVal, newStruct);
+                                 }
+
+                                 // ************************************************************************
+                                 if (stats->options & PS_STAT_SAMPLE_MEDIAN) {
+                                     p_psArraySampleMedian(myVector, maskVector, maskVal, newStruct);
+                                 }
+
+                                 // ************************************************************************
+                                 if (stats->options & PS_STAT_SAMPLE_STDEV) {
+                                     p_psArraySampleStdev(myVector, maskVector, maskVal, newStruct);
+                                 }
+
+                                 // ************************************************************************
+                                 if ((stats->options & PS_STAT_SAMPLE_UQ) ||
+                                         (stats->options & PS_STAT_SAMPLE_LQ)) {
+                                     p_psArraySampleQuartiles(myVector, maskVector, maskVal, newStruct);
+                                 }
+
+
+
+
+                                 if (stats->options & PS_STAT_ROBUST_MEAN) {
+                                     newStruct->robustMean = p_psArrayXXX(myVector, maskVector, maskVal);
+                                 }
+
+                                 if (stats->options & PS_STAT_ROBUST_MEAN_NVALUES) {
+                                     newStruct->robustMeanNvalues = p_psArrayXXX(myVector, maskVector, maskVal);
+                                 }
+
+                                 if (stats->options & PS_STAT_ROBUST_MEDIAN) {
+                                     newStruct->robustMedian = p_psArrayXXX(myVector, maskVector, maskVal);
+                                 }
+
+                                 if (stats->options & PS_STAT_ROBUST_MEDIAN_NVALUES) {
+                                     newStruct->robustMedianNvalues = p_psArrayXXX(myVector, maskVector, maskVal);
+                                 }
+
+                                 if (stats->options & PS_STAT_ROBUST_MODE) {
+                                     newStruct->robustMode = p_psArrayXXX(myVector, maskVector, maskVal);
+                                 }
+
+                                 if (stats->options & PS_STAT_ROBUST_MODE_NVALUES) {
+                                     newStruct->robustModeNvalues = p_psArrayXXX(myVector, maskVector, maskVal);
+                                 }
+
+                                 if (stats->options & PS_STAT_ROBUST_STDEV) {
+                                     newStruct->robustStdev = p_psArrayXXX(myVector, maskVector, maskVal);
+                                 }
+
+                                 if ((stats->options & PS_STAT_ROBUST_UQ) ||
+                                         (stats->options & PS_STAT_ROBUST_LQ)) {
+                                     newStruct->robustLQ = p_psArrayXXX(myVector, maskVector, maskVal);
+                                 }
+
+                                 if (stats->options & PS_STAT_CLIPPED_MEAN) {
+                                     newStruct->clippedMean = p_psArrayXXX(myVector, maskVector, maskVal);
+                                 }
+
+                                 if (stats->options & PS_STAT_CLIPPED_MEAN_NVALUES) {
+                                     newStruct->clippedMeanNvalues = p_psArrayXXX(myVector, maskVector, maskVal);
+                                 }
+
+                                 if (stats->options & PS_STAT_CLIPPED_MEAN_NSIGMA) {
+                                     newStruct->clipSigma = p_psArrayXXX(myVector, maskVector, maskVal);
+                                 }
+
+                                 if (stats->options & PS_STAT_CLIPPED_STDEV) {
+                                     newStruct->clippedStdev = p_psArrayXXX(myVector, maskVector, maskVal);
+                                 }
+
+
+                                 //    OLD CODE: Should we check for an unknown option?
+                                 //    default:
+                                 //        psAbort(__func__, "Unknown options 0x%x.\n", stats->options);
+
+                                 return(newStruct);
+                             }