statistiken.h

Go to the documentation of this file.

// -*- mode: c++; indent-tabs-mode: nil; c-basic-offset: 4; coding: iso-8859-1; -*-

/*
ACT-CV - Machine Vision for Cognitive Modeling
Copyright (c) 2008 Marc Halbruegge

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/


#ifndef _STATISTIKEN_H
#define _STATISTIKEN_H
#include <stdexcept>
#include <vector>
#include <algorithm>
#include <cmath>

class statistics_exn : public std::runtime_error{
public:
    statistics_exn() : std::runtime_error("Statistics") {
    }
};

template<class _t> 
void InitZero(_t &x) {
    x = static_cast<_t>(0);
};



template <class _t> class Mean { 
protected: 
public: 
    _t summe; 
    int n; 
 
    Mean() { 
        init(); 
    } 
    void init() { 
        InitZero(summe); 
        n=0; 
    } 
    void add(_t d){ 
        summe+=d; 
        n++; 
    } 
    int get_num_cases() const {
        return n;
    }
    _t get_mean() const { 
        if (n < 1) throw statistics_exn(); 
        return summe/n; 
    } 
}; 
 
template <class _t> class MeanMinMax { 
protected: 
public: 
    _t summe; 
    _t minimum, maximum;
    int n; 
 
    MeanMinMax() { 
        init(); 
    } 
    void init() { 
        InitZero(summe); 
        n=0; 
    } 
    void add(_t d){ 
        summe+=d;
        if (n==0) {
            minimum=d;
            maximum=d;
        } else {
            if (d<minimum) minimum=d;
            if (d>maximum) maximum=d;
        }
        n++; 
    } 
    int get_num_cases() const {
        return n;
    }
    _t get_mean() const { 
        if (n < 1) throw statistics_exn(); 
        return summe/n; 
    }
    _t get_min() const {
        return minimum;
    } 
    _t get_max() const {
        return maximum;
    } 
}; 

template<class _t> class MeanZero : public Mean<_t> { 
};

template<class _t>
class SquareOperation {
public:
    typedef _t sq_t;

    static sq_t square(const _t &x) {
        return x*x;
    }
};



template<class _t> class Var : public Mean<_t>, public SquareOperation<_t> { 
protected: 
public: 
    typename SquareOperation<_t>::sq_t summeQ; 
 
    Var() { 
        init(); 
    } 

    void init() { 
        Mean<_t>::init();
        InitZero(summeQ); 
    } 

    void add(_t d) { 
        Mean<_t>::add(d); 
        summeQ += square(d); 
    } 

    typename SquareOperation<_t>::sq_t get_var() const { 
#if 0
        if ((Mean<_t>::n<=1)||((summeQ-Mean<_t>::summe*Mean<_t>::summe/Mean<_t>::n)<(_t)0))  
            throw statistics_exn(); 
#else
        if (Mean<_t>::n<=1) throw statistics_exn(); 
#endif
        return (summeQ-square(Mean<_t>::summe)/Mean<_t>::n)/(Mean<_t>::n-1); 
    } 
}; 
 
template <class _t> class Corr { 
protected: 
    Var<_t> x,y; 
    _t summeXY;
    int n; 
public: 
    Corr() { 
        init(); 
    } 
    void init() { 
        InitZero(summeXY); 
        x.init(); 
        y.init(); 
        n=0;
    } 
    void add(_t a, _t b){ 
        summeXY+=a*b; 
        x.add(a); 
        y.add(b);
        n++; 
    } 
    int get_num_cases() const {
        return n;
    }
    _t get_squared_corr() const { 
        if ( (x.n < 2) || 
             (x.get_var() <= (_t)0) ||
             (y.get_var() <= (_t)0)) {
            throw statistics_exn(); 
        }
 
        return (summeXY - x.summe*y.summe/x.n)*(summeXY - x.summe*y.summe/x.n)/ 
            ((x.summeQ-x.summe*x.summe/x.n)*(y.summeQ-y.summe*y.summe/y.n)); 
    } 
}; 
 
template <class _t> class Regr : public Corr<_t> { 
public: 
    _t get_y(_t xw) { 
        return xw*get_b_yx()+get_a_yx(); 
    } 
    _t get_a_yx() { 
        //Y-Achsenabschnitt 
        return Corr<_t>::y.get_mean()-get_b_yx()*Corr<_t>::x.get_mean(); 
    } 
    _t get_b_yx() { 
        //Steigung 
        if (Corr<_t>::x.get_var()<=0.0) throw statistics_exn(); 
        return (Corr<_t>::summeXY - Corr<_t>::x.summe*Corr<_t>::y.summe/Corr<_t>::x.n)/ 
            (Corr<_t>::x.summeQ-Corr<_t>::x.summe*Corr<_t>::x.summe/Corr<_t>::x.n); 
    } 
    _t get_b(int i) {
        switch(i) {
        case 0: return get_a_yx();
        case 1: return get_b_yx();
        default: throw statistics_exn();
        }
    }
}; 
 

class TrimmedMean {
    std::vector<double> data;
    Var<double> avg;
public:
    void Init() {
        data.clear();
    }      
    void Add(double d) {
        data.push_back(d);
    }
    void Compute(double margin=.2) {
        std::sort(data.begin(),data.end());
        avg.init();
        for (unsigned int i=static_cast<unsigned int>(data.size()*margin);
            i < static_cast<unsigned int>(data.size()*(1.0-margin));i++) {
            avg.add(data[i]);
        }
    }
    double GetMean() const {
        return avg.get_mean();
    }
    double GetVar() const {
        return avg.get_var();
    }
    double GetStDev() const {
        return sqrt(GetVar());
    }
    unsigned int GetNumCases() const {
        return avg.get_num_cases();
    }
};

 
 
#endif //_STATISTIKEN_H