class.ilStatistics.php

Go to the documentation of this file.

<?php
/* Copyright (c) 1998-2013 ILIAS open source, Extended GPL, see docs/LICENSE */

    define("NAN_HANDLING_REMOVE", 0);
    define("NAN_HANDLING_ZERO", 1);

class ilStatistics
{
    public $nan_handling;
    
    public $stat_data;
    
    public function __construct($nan_handling = NAN_HANDLING_REMOVE)
    {
        $this->nan_handling = $nan_handling;
        $this->stat_data = array();
    }
    
    public function setNANHandling($nan_handling = NAN_HANDLING_REMOVE)
    {
        $this->nan_handling = $nan_handling;
    }
    
    public function getNANHandling()
    {
        return $this->nan_handling;
    }
    
    public function setData($stat_data)
    {
        $this->stat_data = array_values($stat_data);
        $this->validate();
    }
    
    public function getData()
    {
        return $this->stat_data;
    }

    public function min()
    {
        if (count($this->stat_data)) {
            $min = min($this->stat_data);
        } else {
            $min = false;
        }
        return $min;
    }

    public function max()
    {
        if (count($this->stat_data)) {
            $max = max($this->stat_data);
        } else {
            $max = false;
        }
        return $max;
    }

    public function count()
    {
        return count($this->stat_data);
    }

    public function sum_n($n)
    {
        $sum_n = false;
        if (count($this->stat_data)) {
            $sum_n = 0;
            foreach ($this->stat_data as $value) {
                $sum_n += pow((double) $value, (double) $n);
            }
        }
        return $sum_n;
    }

    public function sum()
    {
        return $this->sum_n(1);
    }


    public function sum2()
    {
        return $this->sum_n(2);
    }
    
    public function product_n($n)
    {
        $prod_n = false;
        if (count($this->stat_data)) {
            if ($this->min() === 0) {
                return 0.0;
            }
            $prod_n = 1.0;
            foreach ($this->stat_data as $value) {
                $prod_n *= pow((double) $value, (double) $n);
            }
        }
        return $prod_n;
    }

    public function product($n)
    {
        return $this->product_n(1);
    }

    public function arithmetic_mean()
    {
        $sum = $this->sum();
        if ($sum === false) {
            return false;
        }
        $count = $this->count();
        if ($count == 0) {
            return false;
        }
        return (double) ($sum / $count);
    }

    public function geometric_mean()
    {
        $prod = $this->product();
        if (($prod === false) or ($prod === 0)) {
            return false;
        }
        $count = $this->count();
        if ($count == 0) {
            return false;
        }
        return pow((double) $prod, (double) (1 / $count));
    }

    public function harmonic_mean()
    {
        $min = $this->min();
        if (($min === false) or ($min === 0)) {
            return false;
        }
        $count = $this->count();
        if ($count == 0) {
            return false;
        }
        $sum = 0;
        foreach ($this->stat_data as $value) {
            $sum += 1 / $value;
        }
        return $count / $sum;
    }

    public function median()
    {
        $median = false;
        if (count($this->stat_data)) {
            $median = 0;
            $count = $this->count();
            if ((count($this->stat_data) % 2) == 0) {
                $median = ($this->stat_data[($count / 2) - 1] + $this->stat_data[($count / 2)]) / 2;
            } else {
                $median = $this->stat_data[(($count + 1) / 2) - 1];
            }
        }
        return $median;
    }
    
    public function rank($value)
    {
        if (!is_numeric($value)) {
            return false;
        }
        $rank = array_search($value, $this->stat_data);
        if ($rank !== false) {
            $rank = $this->count() - $rank;
        }
        return $rank;
    }
    
    public function rank_median()
    {
        $count = $this->count();
        if ($count == 0) {
            return false;
        }
        
        if (($count % 2) == 0) {
            $rank_median = ($count + 1) / 2;
        } else {
            $rank_median = ($count + 1) / 2;
        }
        return $rank_median;
    }
    
    public function quantile($n)
    {
        $count = $this->count();
        if ($count == 0) {
            return false;
        }
        $nprod = ($n / 100) * $count;
        if (intval($nprod) == $nprod) {
            $k = $nprod;
            if ($k == 0) {
                return $this->stat_data[$k];
            } elseif ($k == $count) {
                return $this->stat_data[$k - 1];
            } else {
                return ($this->stat_data[$k - 1] + $this->stat_data[$k]) / 2;
            }
        } else {
            $k = ceil($nprod);
            return $this->stat_data[$k - 1];
        }
    }
    
    public function validate()
    {
        $result = true;
        foreach ($this->stat_data as $key => $value) {
            if (!is_numeric($value)) {
                switch ($this->nan_handling) {
                    case NAN_HANDLING_REMOVE:
                        unset($this->stat_data[$key]);
                        break;
                    case NAN_HANDLING_ZERO:
                        $this->stat_data[$key] = 0;
                        break;
                    default:
                        $result = false;
                }
            }
        }
        sort($this->stat_data);
        return $result;
    }
}