devfym\IntelliPHP\Data\DataFrame

Complexity

Total Complexity

30

Size/Duplication

Total Lines	222
Duplicated Lines	0 %

Importance

Changes	3
Bugs	1	Features	2

13 Methods

Rating	Name	Duplication	Size	Complexity
A	std()	0	12	3
A	median()	0	3	1
A	getColumns()	0	3	1
A	transpose()	0	12	2
A	variance()	0	12	3
A	getNumericColumns()	0	13	3
A	mean()	0	12	3
A	getIndex()	0	3	1
A	readArray()	0	17	3
A	min()	0	12	3
A	max()	0	12	3
A	__construct()	0	2	1
A	quartile()	0	12	3

<?php

namespace devfym\IntelliPHP\Data;

use devfym\IntelliPHP\Math\StatisticInterface;

class DataFrame implements StatisticInterface
{
    /**
     * @var array
     * List of Column names.
     */
    private $columns = [];

    /**
     * @var int
     * Number of Sample.
     */
    private $index = 0;

    /**
     * DataFrame constructor.
     */
    public function __construct()
    {
        //
    }

    /**
     * @param array $arr
     * @return array
     * Transpose array.
     */
    public function transpose($arr = []) : array
    {
        $columns = array_keys($arr[0]);

        $arr = array_map(null, ...$arr);

        foreach ($columns as $index => $column) {
            $arr[$column] = $arr[$index];
            unset($arr[$index]);
        }

        return $arr;
    }

    /**
     * @param array $arr
     * @param bool $transpose
     * Store given array-formatted data into series.
     */
    public function readArray($arr = [], $transpose = false) : void
    {

        if ($transpose === true) {
            $arr = $this->transpose($arr);
        }

        // Set Columns
        $this->columns = array_keys($arr);

        // Set Index
        $this->index = count($arr[$this->columns[0]]);

        // Create Series instance for each column.
        foreach ($this->columns as $column) {
            $this->{$column} = new Series();
            $this->{$column}->setSample($arr[$column]);
        }
    }

    /**
     * @return array
     * Get list of column names.
     */
    public function getColumns() : array
    {
        return $this->columns;
    }

    public function getNumericColumns() : array {

        $columns = $this->columns;

        $numeric = [];

        foreach ($columns as $col) {
            if ($this->{$col}->dataType() == 'Numeric') {
                array_push($numeric, $col);
            }
        }

        return $numeric;
    }

    /**
     * @return int
     * Get Number of Sample.
     */
    public function getIndex() : int
    {
        return $this->index;
    }

    /**
     * @param int $floatPoint
     * @return array
     * Get list of mean value in DataFrame.
     */
    public function mean($floatPoint = 1) : array
    {
        // Initialize mean.
        $mean = [];

        foreach ($this->columns as $column) {
            if ($this->{$column}->dataType() == 'Numeric') {
                $mean[$column] = $this->{$column}->mean($floatPoint);
            }
        }

        return $mean;
    }

    /**
     * @param int $floatPoint
     * @return array
     * Get list of max value in DataFrame.
     */
    public function max($floatPoint = 2) : array
    {
        // Initialize max.
        $max = [];

        foreach ($this->columns as $column) {
            if ($this->{$column}->dataType() == 'Numeric') {
                $max[$column] = $this->{$column}->max($floatPoint);
            }
        }

        return $max;
    }

    /**
     * @param int $floatPoint
     * @return array
     * Get list of min value in DataFrame.
     */
    public function min($floatPoint = 2) : array
    {
        // Initialize min.
        $min = [];

        foreach ($this->columns as $column) {
            if ($this->{$column}->dataType() == 'Numeric') {
                $min[$column] = $this->{$column}->min($floatPoint);
            }
        }

        return $min;
    }

    /**
     * @param int $Q
     * @param int $floatPoint
     * @return array
     * Get list of Q-th quartile value in DataFrame.
     */
    public function quartile($Q = 1, $floatPoint = 2) : array
    {
        // Initialize quartile.
        $quartile = [];

        foreach ($this->columns as $column) {
            if ($this->{$column}->dataType() == 'Numeric') {
                $quartile[$column] = $this->{$column}->quartile($Q, $floatPoint);
            }
        }

        return $quartile;
    }

    /**
     * @param int $floatPoint
     * @return array
     * Get list of 2nd Quartile value in DataFrame.
     */
    public function median($floatPoint = 2) : array
    {
        return $this->quartile(2, $floatPoint);
    }

    /**
     * @param int $floatPoint
     * @return array
     * Get list of Variance in DataFrame.
     */
    public function variance($floatPoint = 4) : array
    {
        // Initialize quartile.
        $variance = [];

        foreach ($this->columns as $column) {
            if ($this->{$column}->dataType() == 'Numeric') {
                $variance[$column] = $this->{$column}->variance($floatPoint);
            }
        }

        return $variance;
    }

    /**
     * @param int $floatPoint
     * @return array
     * Get list of Standard Deviation in DataFrame.
     */
    public function std($floatPoint = 2) : array
    {
        // Initialize quartile.
        $std = [];

        foreach ($this->columns as $column) {
            if ($this->{$column}->dataType() == 'Numeric') {
                $std[$column] = $this->{$column}->std($floatPoint);
            }
        }

        return $std;
    }
}