Statistics.h

Go to the documentation of this file.

/*
 * 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 3 of the License, or
 * (at your option) any later version.
 *
 * Written (W) 2011-2012 Heiko Strathmann
 * Copyright (C) 2011 Berlin Institute of Technology and Max-Planck-Society
 *
 * ALGLIB Copyright 1984, 1987, 1995, 2000 by Stephen L. Moshier under GPL2+
 * http://www.alglib.net/
 * See method comments which functions are taken from ALGLIB (with adjustments
 * for shogun)
 */

#ifndef __STATISTICS_H_
#define __STATISTICS_H_

#include <shogun/lib/config.h>
#include <shogun/base/SGObject.h>
#include <shogun/lib/SGVector.h>
#include <shogun/io/SGIO.h>

namespace shogun
{
template<class T> class SGMatrix;
template<class T> class SGSparseMatrix;

class CStatistics: public CSGObject
{

public:

    template<class T>
        static floatmax_t mean(SGVector<T> vec)
        {
            floatmax_t sum = 0;

            for ( index_t i = 0 ; i < vec.vlen ; ++i )
                sum += vec[i];

            return sum/vec.vlen;
        }

    static float64_t median(SGVector<float64_t> values, bool modify=false,
            bool in_place=false);

    static float64_t matrix_median(SGMatrix<float64_t> values,
            bool modify=false, bool in_place=false);

    static float64_t variance(SGVector<float64_t> values);

    static float64_t std_deviation(SGVector<float64_t> values);

    static SGVector<float64_t> matrix_mean(SGMatrix<float64_t> values,
            bool col_wise=true);

    static SGVector<float64_t> matrix_variance(SGMatrix<float64_t> values,
            bool col_wise=true);

    static SGVector<float64_t> matrix_std_deviation(
            SGMatrix<float64_t> values, bool col_wise=true);

#ifdef HAVE_LAPACK

    static SGMatrix<float64_t> covariance_matrix(
            SGMatrix<float64_t> observations, bool in_place=false);
#endif //HAVE_LAPACK

    static float64_t confidence_intervals_mean(SGVector<float64_t> values,
            float64_t alpha, float64_t& conf_int_low, float64_t& conf_int_up);

    static float64_t inverse_student_t(int32_t k, float64_t p);

    static float64_t inverse_incomplete_beta(float64_t a, float64_t b,
            float64_t y);

    static float64_t incomplete_beta(float64_t a, float64_t b, float64_t x);

    static float64_t inverse_normal_cdf(float64_t y0);

    static float64_t inverse_normal_cdf(float64_t y0, float64_t mean,
                float64_t std_dev);

    static inline float64_t lgamma(float64_t x)
    {
        return ::lgamma((double) x);
    }

    static inline floatmax_t lgammal(floatmax_t x)
    {
#ifdef HAVE_LGAMMAL
        return ::lgammal((long double) x);
#else
        return ::lgamma((double) x);
#endif // HAVE_LGAMMAL
    }

    static inline float64_t tgamma(float64_t x)
    {
        return ::tgamma((double) x);
    }

    static float64_t incomplete_gamma(float64_t a, float64_t x);

    static float64_t incomplete_gamma_completed(float64_t a, float64_t x);

    static float64_t gamma_cdf(float64_t x, float64_t a, float64_t b);

    static float64_t inverse_gamma_cdf(float64_t p, float64_t a, float64_t b);

    static float64_t inverse_incomplete_gamma_completed(float64_t a,
            float64_t y0);

    static float64_t normal_cdf(float64_t x, float64_t std_dev=1);

    static float64_t lnormal_cdf(float64_t x);

    static float64_t chi2_cdf(float64_t x, float64_t k);

    static float64_t fdistribution_cdf(float64_t x, float64_t d1, float64_t d2);

    static float64_t erfc8_weighted_sum(float64_t x);

    static float64_t error_function(float64_t x);

    static float64_t error_function_complement(float64_t x);

    static float64_t mutual_info(float64_t* p1, float64_t* p2, int32_t len);

    static float64_t relative_entropy(
            float64_t* p, float64_t* q, int32_t len);

    static float64_t entropy(float64_t* p, int32_t len);

    static SGVector<float64_t> fishers_exact_test_for_multiple_2x3_tables(SGMatrix<float64_t> tables);

    static float64_t fishers_exact_test_for_2x3_table(SGMatrix<float64_t> table);

    static SGVector<int32_t> sample_indices(int32_t sample_size, int32_t N);

    virtual const char* get_name() const
    {
        return "Statistics";
    }

    static float64_t dlgamma(float64_t x);

    struct SigmoidParamters
    {
        float64_t a;

        float64_t b;
    };

    static SigmoidParamters fit_sigmoid(SGVector<float64_t> scores);

#ifdef HAVE_EIGEN3

    static float64_t log_det_general(const SGMatrix<float64_t> A);

    static float64_t log_det(SGMatrix<float64_t> m);

    static float64_t log_det(const SGSparseMatrix<float64_t> m);

    static SGMatrix<float64_t> sample_from_gaussian(SGVector<float64_t> mean,
    SGMatrix<float64_t> cov, int32_t N=1, bool precision_matrix=false);

    static SGMatrix<float64_t> sample_from_gaussian(SGVector<float64_t> mean,
    SGSparseMatrix<float64_t> cov, int32_t N=1, bool precision_matrix=false);
#endif //HAVE_EIGEN3

    static const float64_t ERFC_CASE1;

    static const float64_t ERFC_CASE2;

protected:
    static float64_t ibetaf_incompletebetaps(float64_t a, float64_t b,
            float64_t x, float64_t maxgam);

    static float64_t ibetaf_incompletebetafe(float64_t a, float64_t b,
            float64_t x, float64_t big, float64_t biginv);

    static float64_t ibetaf_incompletebetafe2(float64_t a, float64_t b,
            float64_t x, float64_t big, float64_t biginv);

    static inline bool equal(float64_t a, float64_t b) { return a==b; }

    static inline bool not_equal(float64_t a, float64_t b) { return a!=b; }

    static inline bool less(float64_t a, float64_t b) { return a<b; }

    static inline bool less_equal(float64_t a, float64_t b) { return a<=b; }

    static inline bool greater(float64_t a, float64_t b) { return a>b; }

    static inline bool greater_equal(float64_t a, float64_t b) { return a>=b; }
};

template <>
    inline floatmax_t CStatistics::mean<complex128_t>(SGVector<complex128_t> vec)
    {
        SG_SNOTIMPLEMENTED
        return floatmax_t(0.0);
    }

}

#endif /* __STATISTICS_H_ */