// file: $isip/class/algo/Statistics/Statistics.h // version: $Id: Statistics.h 8314 2002-07-09 02:19:50Z picone $ // // make sure definitions are only made once // #ifndef ISIP_STATISTICS #define ISIP_STATISTICS // isip include files // #ifndef ISIP_ALGORITHM_BASE #include #endif // Statistics : a class that calculates various statistical parameters // of the input data such as the maximum, mean, and variance. two types // of implementations have been supported - FRAME_INTERNAL and // ACCUMULATE. FRAME_INTERNAL computes the requested feature // over one frame of data. this is useful for computing the average // value of a signal on a frame-by-frame basis. // // ACCUMULATE computes the requested feature across all frames, and // can be used to output a value for the entire file. this is useful // when computing the mean value of a signal for the entire file. // class Statistics : public AlgorithmBase { //--------------------------------------------------------------------------- // // public constants // //--------------------------------------------------------------------------- public: // define the class name // static const String CLASS_NAME; //---------------------------------------- // // other important constants // //---------------------------------------- // define algorithm choices // enum ALGORITHM { MINIMUM = 0, MINIMUM_MAG, MAXIMUM, MAXIMUM_MAG, MEAN, MEDIAN, VARIANCE, STDEV, SKEW, KURTOSIS, DEF_ALGORITHM = MINIMUM }; // define implementation choices // enum IMPLEMENTATION { LINEAR = 0, DEF_IMPLEMENTATION = LINEAR }; // define static NameMap objects // static const NameMap ALGO_MAP; static const NameMap IMPL_MAP; //---------------------------------------- // // i/o related constants // //---------------------------------------- static const String DEF_PARAM; static const String PARAM_ALGORITHM; static const String PARAM_IMPLEMENTATION; static const String PARAM_CMODE; static const String PARAM_DMODE; //---------------------------------------- // // default values and arguments // //---------------------------------------- // define the default value(s) of the class data // static const int32 DEF_DELAY = 0; static const int32 DEF_NUM_FRAMES = 0; // define default argument(s) // static const AlgorithmData::COEF_TYPE DEF_COEF_TYPE = AlgorithmData::DEF_CTYPE; //---------------------------------------- // // error codes // //---------------------------------------- static const int32 ERR = 71800; //--------------------------------------------------------------------------- // // protected data // //--------------------------------------------------------------------------- protected: // algorithm name // ALGORITHM algorithm_d; // implementation type // IMPLEMENTATION implementation_d; // static memory manager // static MemoryManager mgr_d; // define a variety of accumulators for input vectors: // note that the median operation is rather expensive since // it requires keeping track of all prior data members. // Vector accum_sum_d; Vector accum_sumsqr_d; Vector accum_result_d; Vector accum_frame_data_d; Vector > accum_frame_buff_d; // define some useful counters // int32 accum_samples_d; int32 accum_frames_d; // only return a value once it has seen all data // bool8 is_calculated_d; //--------------------------------------------------------------------------- // // required public methods // //--------------------------------------------------------------------------- public: // method: name // static const String& name() { return CLASS_NAME; } // other static methods // static bool8 diagnose(Integral::DEBUG debug_level); // debug methods: // setDebug is inherited from the AlgorithmBase class // bool8 debug(const unichar* msg) const; // method: destructor // ~Statistics() {} // method: default constructor // Statistics(ALGORITHM algorithm = DEF_ALGORITHM, IMPLEMENTATION implementation = DEF_IMPLEMENTATION); // method: copy constructor // Statistics(const Statistics& arg) { is_calculated_d = false; assign(arg); } // assign methods // bool8 assign(const Statistics& arg); // method: operator= // Statistics& operator= (const Statistics& arg) { assign(arg); return *this; } // i/o methods // int32 sofSize() const; bool8 read(Sof& sof, int32 tag, const String& name = CLASS_NAME); bool8 write(Sof& sof, int32 tag, const String& name = CLASS_NAME) const; bool8 readData(Sof& sof, const String& pname = DEF_PARAM, int32 size = SofParser::FULL_OBJECT, bool8 param = true, bool8 nested = false); bool8 writeData(Sof& sof, const String& pname = DEF_PARAM) const; // equality methods // bool8 eq(const Statistics& arg) const; // method: new // static void* operator new(size_t size) { return mgr_d.get(); } // method: new[] // static void* operator new[](size_t size) { return mgr_d.getBlock(size); } // method: delete // static void operator delete(void* ptr) { mgr_d.release(ptr); } // method: delete[] // static void operator delete[](void* ptr) { mgr_d.releaseBlock(ptr); } // method: setGrowSize // static bool8 setGrowSize(int32 grow_size) { return mgr_d.setGrow(grow_size); } // method: clear // bool8 clear(Integral::CMODE ctype = Integral::DEF_CMODE); //--------------------------------------------------------------------------- // // class-specific public methods // set methods // //--------------------------------------------------------------------------- // method: setAlgorithm // bool8 setAlgorithm(ALGORITHM algorithm) { algorithm_d = algorithm; is_calculated_d = false; is_valid_d = false; return true; } // method: setImplementation // bool8 setImplementation(IMPLEMENTATION implementation) { implementation_d = implementation; is_calculated_d = false; is_valid_d = false; return true; } // method: set // bool8 set(ALGORITHM algorithm = DEF_ALGORITHM, IMPLEMENTATION implementation = DEF_IMPLEMENTATION) { algorithm_d = algorithm; implementation_d = implementation; is_valid_d = false; return true; } // other set methods // bool8 setAccumulateVar(int32 num_channel, int32 dimension); //--------------------------------------------------------------------------- // // class-specific public methods // get methods // //--------------------------------------------------------------------------- // method: getAlgorithm // ALGORITHM getAlgorithm() const { return algorithm_d; } // method: getImplementation // IMPLEMENTATION getImplementation() const { return implementation_d; } // bool8 get(ALGORITHM& algorithm, IMPLEMENTATION& implementation) const { algorithm = algorithm_d; implementation = implementation_d; return true; } //--------------------------------------------------------------------------- // // class-specific public methods: // computational methods // //--------------------------------------------------------------------------- // compute methods // bool8 compute(VectorFloat& output, const VectorFloat& input, AlgorithmData::COEF_TYPE input_coef_type = DEF_COEF_TYPE, int32 index = DEF_CHANNEL_INDEX); //--------------------------------------------------------------------------- // // class-specific public methods: // public methods required by the AlgorithmBase interface contract // //--------------------------------------------------------------------------- // assign method // bool8 assign(const AlgorithmBase& arg); // equality method // bool8 eq(const AlgorithmBase& arg) const; // method: className // const String& className() const { return CLASS_NAME; } // method: init // bool8 init() { is_calculated_d = false; return true; } // apply methods // bool8 apply(Vector& output, const Vector< CircularBuffer >& input); // method to set the parser // bool8 setParser(SofParser* parser); //--------------------------------------------------------------------------- // // private methods // //--------------------------------------------------------------------------- private: // common i/o methods // bool8 readDataCommon(Sof& sof, const String& pname, int32 size = SofParser::FULL_OBJECT, bool8 param = true, bool8 nested = false); bool8 writeDataCommon(Sof& sof, const String& pname) const; // mode and computation mode-specific computation methods // bool8 computeFrameInt(VectorFloat& output, const VectorFloat& input, AlgorithmData::COEF_TYPE input_coef_type = DEF_COEF_TYPE, int32 index = DEF_CHANNEL_INDEX); bool8 computeFrameAccumulate(VectorFloat& output, const VectorFloat& input, AlgorithmData::COEF_TYPE input_coef_type = DEF_COEF_TYPE, int32 index = DEF_CHANNEL_INDEX); bool8 computeSampleAccumulate(VectorFloat& output, const VectorFloat& input, AlgorithmData::COEF_TYPE input_coef_type = DEF_COEF_TYPE, int32 index = DEF_CHANNEL_INDEX); // algorithm specific computation methods // bool8 computeMin(VectorFloat& output, const VectorFloat& input); bool8 computeMax(VectorFloat& output, const VectorFloat& input); bool8 computeMinMag(VectorFloat& output, const VectorFloat& input); bool8 computeMaxMag(VectorFloat& output, const VectorFloat& input); bool8 computeMean(VectorFloat& output, const VectorFloat& input); bool8 computeMedian(VectorFloat& output, const VectorFloat& input); bool8 computeVar(VectorFloat& output, const VectorFloat& input); bool8 computeStdDev(VectorFloat& output, const VectorFloat& input); }; // end of include file // #endif