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-2016 Heiko Strathmann
 * Copyright (C) 2011 Berlin Institute of Technology and Max-Planck-Society
 *
 * Most cdf routines are wrappers for CDFLIB, part of the public domain NETLIB.
 * https://people.sc.fsu.edu/~jburkardt/f_src/cdflib/cdflib.html
 */

#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 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);

    static SGMatrix<float64_t> covariance_matrix(
            SGMatrix<float64_t> observations, bool in_place=false);

    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 gamma_cdf(float64_t x, float64_t a, float64_t b);

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

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

    static float64_t inverse_normal_cdf(float64_t y0, float64_t mean=0,
            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 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);

    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);

    static const float64_t ERFC_CASE1;

    static const float64_t ERFC_CASE2;


};

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

}

#endif /* __STATISTICS_H_ */