mi32/statunivar.h

Go to the documentation of this file.

#ifndef  INC_MI32_STATUNIVAR_H
#define  INC_MI32_STATUNIVAR_H

#ifndef  INC_MI32_NUMTYPE_H
#include <mi32/numtype.h>
#endif

#ifndef  INC_MI32_RANGE_H
#include <mi32/range.h>
#endif

#ifndef  INC_MI32_DOUBLEAR_H
#include <mi32/doublear.h>
#endif

#ifndef  INC_MI32_MISTRING_H
#include <mi32/mistring.h>
#endif

#ifdef GEOMDLL
   #define CLASSLIBEXPORT MI_DLLCLASSEXPORT
#else
   #define CLASSLIBEXPORT MI_DLLCLASSIMPORT
#endif

#ifndef GENERATING_DOXYGEN_OUTPUT
class XMLNODE;
#endif

//=====================================================================================================================

class CLASSLIBEXPORT STAT_UNIVARIATE {
   public:

      STAT_UNIVARIATE ();

      ~STAT_UNIVARIATE ();

      ERRVALUE Accumulate (
         UINT32 NumValues,                
         const void *pValues,             
         const UINT8 *pValidity = 0       
         );

      ERRVALUE Accumulate (
         const STAT_UNIVARIATE& stats     
         );

      ERRVALUE AccumulateCounted (
         const void *pValue,              
         UINT64 count                     
         );

      ERRVALUE AccumulateWeighted (
         const void *pValue,              
         double weight                    
         );

      void Clear (
         );

      double ComputeBinCenter (
         INT32 BinIndex                   
         ) const;

      INT32 ComputeBinIndex (
         double value
         ) const;

      UINT32 ComputeBinIndexLimit (
         double value
         ) const;

      void ComputeBinRange (
         INT32 BinIndex,                  
         DOUBLE_RANGE& BinRange           
         ) const;

      ERRVALUE Finalize ();

      INT32 FindBinIndexPctAbove (
         double pct                       
         ) const;

      INT32 FindBinIndexPctBelow (
         double pct                       
         ) const;

      UINT64 GetBinCount (
         INT32 BinIndex                   
         ) const;

      double GetBinCountWeighted (
         INT32 BinIndex                   
         ) const;

      const DOUBLE_RANGE& GetBinRange (
         ) const { return (m_BinRange); }

      double GetBinWidth (
         INT32 BinIndex = 0               
         ) const;

      UINT64 GetCountAboveMaxBin (
         ) const;

      double GetCountAboveMaxBinWeighted (
         ) const;

      UINT64 GetCountBelowMinBin (
         ) const;

      double GetCountBelowMinBinWeighted (
         ) const;

      UINT64 GetCountInvalid (
         ) const { return (m_CountInvalid); }

      UINT64 GetCountValid (
         ) const;

      double GetCountValidWeighted (
         ) const;

      MISTRING GetDisplayStats (
         ) const;

      double GetMean (
         ) const { return (m_Mean); }

      INT32 GetMedianBinIndex (
         ) const { return (m_MedianBinIndex); }

      INT32 GetModeBinIndex (
         ) const { return (m_ModeBinIndex); }

      UINT32 GetNumBins (
         ) const { return (m_BinCounts.GetNumItems()); }

      NUMTYPE GetNumType (
         ) const { return (m_NumType); }

      double GetStdDev (
         ) const { return (m_StdDev); }

      double GetSum2 (
         ) const { return (m_Sum2); }

      const DOUBLE_RANGE& GetValueRange (
         ) const { return (m_ValueRange); }

      XMLNODE* GetXML (
         XMLNODE *parentnode,             
         const char *nodename             
         ) const;

      bool HasEqualBinWidths (
         ) const { return (true); }

      ERRVALUE Initialize (
         NUMTYPE NumType,                 
         UINT32 NumBins,                  
         double MinBin,                   
         double MaxBin,                   
         double BinWidth = 0              
         );

      ERRVALUE Initialize (
         NUMTYPE NumType,                 
         const STAT_UNIVARIATE& existing  
         ) { return (Initialize(NumType,existing.m_BinCounts.GetNumItems(),existing.m_BinRange.GetMinimum(),existing.m_BinRange.GetMaximum(),existing.m_BinWidth)); }

      bool IsValid (
         ) const { return (m_State == STATE_Valid); }

      ERRVALUE Set (
         UINT64 CountValid,                  
         UINT64 CountBelowMinBin,            
         UINT64 CountAboveMaxBin,            
         UINT64 CountInvalid,                
         double Mean,                        
         double Sum2,                        
         const DOUBLE_RANGE& ValueRange,     
         const DOUBLE_RANGE& BinRange,       
         double BinWidth,                    
         const void *BinCounts,              
         UINT32 NumBins,                     
         int BinBytes,                       
         NUMTYPE NumType = NUMTYPE_Invalid   
         );

      void SetAllInvalid (
         UINT64 CountInvalid                 
         );

      ERRVALUE SetFromXML (
         const XMLNODE *xmlnode              
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      enum STATE {
         STATE_Invalid,
         STATE_Accumulating,
         STATE_Valid
         };

      STATE m_State;
      NUMTYPE m_NumType;
      DOUBLE_RANGE m_ValueRange;
      DOUBLE_RANGE m_BinRange;
      double m_BinWidth;               // Bin width if equal
      double m_Mean;                   // Mean
      double m_StdDev;                 // Standard deviation
      double m_Sum2;                   // Sum of squares
      UINT64 m_CountBelowMinBin;
      UINT64 m_CountAboveMaxBin;
      UINT64 m_CountValid;
      UINT64 m_CountInvalid;
      double m_WeightedBelowMinBin;
      double m_WeightedAboveMaxBin;
      double m_WeightedTotal;
      INT32 m_MedianBinIndex;
      INT32 m_ModeBinIndex;
      DOUBLE_ARRAY<UINT64> m_BinCounts;
      DOUBLE_ARRAY<double> m_BinWeighted;
//    DOUBLE_ARRAY<double> m_BinCenters;
//    DOUBLE_ARRAY<double> m_BinWidths;

      void ClearLow ();
      void ClearWeighted ();
      void ComputeMedianAndMode ();

      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//=====================================================================================================================

#undef   CLASSLIBEXPORT

#endif    // INC_MI32_STATUNIVAR_H

---