Percentiller::insert() - Code Metrics - phperf/percentiller - Measure and Improve Code Quality continuously with Scrutinizer

Percentiller::insert() B
last analyzed 2018-11-29 20:08 UTC

↳ Parent: Percentiller

Complexity

Conditions	6
Paths	10

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	32
rs	8.7857
c	0
b	0
f	0
cc	6
nc	10
nop	2

<?php

namespace Phperf;

class Percentiller
{
    public $maxBuckets = 10;

    private $totalBuckets = 0;
    /** @var  mixed */
    public $min;
    /** @var  mixed */
    public $max;
    /** @var int  */
    public $totalCount = 0;
    /** @var double  */
    public $arithmeticAverage = 0;
    /** @var  array */
    public $buckets;


    /** @var int  */
    public $captureTopItems = 0;
    private $topMetas = array();
    private $topValues = array();
    private $topCount = 0;
    private $topLast = null;

    /** @var int  */
    public $captureBottomItems = 0;
    private $bottomMetas = array();
    private $bottomValues = array();
    private $bottomCount = 0;
    private $bottomLast = null;

    private $sampleId = 0;

    public function add($value, $meta = false)
    {
        $this->arithmeticAverage = $this->arithmeticAverage * ($this->totalCount / ($this->totalCount + 1))
            + $value / ($this->totalCount + 1);

        ++$this->totalCount;


        if ($this->captureTopItems) {
            if ($this->topCount < $this->captureTopItems || $this->topLast === null || $this->topLast < $value) {
                ++$this->sampleId;
                $this->topMetas [$this->sampleId]= $meta;
                $this->topValues [$this->sampleId]= $value;
                ++$this->topCount;

                if ($this->topCount > $this->captureTopItems) {
                    arsort($this->topValues);
                    end($this->topValues);
                    $sampleId = key($this->topValues);
                    unset($this->topValues[$sampleId]);
                    unset($this->topMetas[$sampleId]);
                    --$this->topCount;
                }
            }
        }


        if ($this->captureBottomItems) {
            if ($this->bottomCount < $this->captureBottomItems || $this->bottomLast === null || $this->bottomLast > $value) {
                ++$this->sampleId;
                $this->bottomMetas [$this->sampleId]= $meta;
                $this->bottomValues [$this->sampleId]= $value;
                ++$this->bottomCount;

                if ($this->bottomCount > $this->captureBottomItems) {
                    asort($this->bottomValues);
                    end($this->bottomValues);
                    $sampleId = key($this->bottomValues);
                    unset($this->bottomValues[$sampleId]);
                    unset($this->bottomMetas[$sampleId]);
                    --$this->bottomCount;
                }
            }
        }


        if (null === $this->buckets) {
            $this->buckets = array(array($value, $value, 1, $meta));
            $this->min = $this->max = $value;
            $this->totalBuckets = 1;
        }
        else {
            if ($value < $this->min) {
                $this->min = $value;
                array_unshift($this->buckets, array($value, $value, 1, $meta));
                $this->totalBuckets++;
            }
            elseif ($value > $this->max) {
                $this->max = $value;
                array_push($this->buckets, array($value, $value, 1, $meta));
                $this->totalBuckets++;
            }
            elseif ($value === $this->min) {
                ++$this->buckets[0][2];
            }
            elseif ($value === $this->max) {
                ++$this->buckets[$this->totalBuckets - 1][2];
            }
            else {
                $this->insert($value, $meta);
            }
        }

        if ($this->totalBuckets > $this->maxBuckets) {
            $this->shrink();
        }
    }

    private function insert($value, $meta = false) {
        $left = 0;
        $right = $this->totalBuckets - 1;
        while ($right - $left > 0) {
            $position = (int)(($right + $left)/2);
            $item = $this->buckets[$position];
            if ($value < $item[0]) {
                $right = $position - 1;
            }
            elseif ($value > $item[1]) {
                $left = $position + 1;
            }
            else {
                ++$this->buckets[$position][2];
                return;
            }
        }

        $position = $left;
        $item = $this->buckets[$position];
        if ($value < $item[0]) {
            array_splice($this->buckets, $position, 0, array(array($value, $value, 1, $meta)));
            ++$this->totalBuckets;
        }
        elseif ($value > $item[1]) {
            array_splice($this->buckets, $position + 1, 0, array(array($value, $value, 1, $meta)));
            ++$this->totalBuckets;
        }
        else {
            ++$this->buckets[$position][2];
        }
    }


    private function shrink() {
        $minPosition = 0;
        $minCount = $this->buckets[$minPosition][2];
        $mergePosition = 1;
        $mergeCount = $this->buckets[$mergePosition][2];

        for ($position = 1; $position < $this->totalBuckets; ++$position) {
            $currentCount = $this->buckets[$position][2];
            if ($position === $this->totalBuckets - 1) {
                $currentMergePosition = $position - 1;
            }
            else {
                $currentMergePosition = $this->buckets[$position + 1][2] < $this->buckets[$position - 1][2]
                    ? $position + 1
                    : $position - 1;
            }
            $currentMergeCount = $this->buckets[$currentMergePosition][2];
            if ($currentCount < $minCount
                || ($currentCount === $minCount
                    && $currentMergeCount < $mergeCount)) {
                $minPosition = $position;
                $minCount = $currentCount;
                $mergePosition = $currentMergePosition;
                $mergeCount = $currentMergeCount;
            }
        }

        if ($mergePosition > $minPosition) {
            $this->buckets[$minPosition][1] = $this->buckets[$mergePosition][1];
        }
        else {
            $this->buckets[$minPosition][0] = $this->buckets[$mergePosition][0];
        }
        $this->buckets[$minPosition][2] += $this->buckets[$mergePosition][2];
        unset($this->buckets[$mergePosition]);
        $this->buckets = array_values($this->buckets);
        $this->totalBuckets--;
    }


    public function bottomPercentile($percentile = 0.9) {

        $currentCount = 0;
        $percentileCount = $this->totalCount * $percentile;
        $bucket = array(0, 0, 0);
        for ($i = 0; $i < $this->totalBuckets; ++$i) {
            $bucket = $this->buckets[$i];
            $currentCount += $bucket[2];
            if ($currentCount >= $percentileCount) {
                return $bucket[1];
            }
        }
        return $bucket[1];
    }

    public function topPercentile($percentile = 0.9) {

        $currentCount = 0;
        $percentileCount = $this->totalCount * $percentile;
        $bucket = array(0, 0, 0);
        for ($i = $this->totalBuckets - 1; $i >= 0; --$i) {
            $bucket = $this->buckets[$i];
            $currentCount += $bucket[2];
            if ($currentCount >= $percentileCount) {
                return $bucket[0];
            }
        }
        return $bucket[0];
    }

    public function getTopValues() {
        return array_values($this->topValues);
    }

    public function getTopMetas() {
        $result = array();
        foreach ($this->topValues as $sampleId => $tmp) {
            $result []= $this->topMetas[$sampleId];
        }
        return $result;
    }

    public function getBottomValues() {
        return array_values($this->bottomValues);
    }

    public function getBottomMetas() {
        $result = array();
        foreach ($this->bottomValues as $sampleId => $tmp) {
            $result []= $this->bottomMetas[$sampleId];
        }
        return $result;
    }

}

1		<?php
2
3		namespace Phperf;
4
5		class Percentiller
6		{
7		public $maxBuckets = 10;
8
9		private $totalBuckets = 0;
10		/** @var mixed */
11		public $min;
12		/** @var mixed */
13		public $max;
14		/** @var int */
15		public $totalCount = 0;
16		/** @var double */
17		public $arithmeticAverage = 0;
18		/** @var array */
19		public $buckets;
20
21
22		/** @var int */
23		public $captureTopItems = 0;
24		private $topMetas = array();
25		private $topValues = array();
26		private $topCount = 0;
27		private $topLast = null;
28
29		/** @var int */
30		public $captureBottomItems = 0;
31		private $bottomMetas = array();
32		private $bottomValues = array();
33		private $bottomCount = 0;
34		private $bottomLast = null;
35
36		private $sampleId = 0;
37
38		public function add($value, $meta = false)
39		{
40		$this->arithmeticAverage = $this->arithmeticAverage * ($this->totalCount / ($this->totalCount + 1))
41		+ $value / ($this->totalCount + 1);
42
43		++$this->totalCount;
44
45
46		if ($this->captureTopItems) {
47		if ($this->topCount < $this->captureTopItems \|\| $this->topLast === null \|\| $this->topLast < $value) {
48		++$this->sampleId;
49		$this->topMetas [$this->sampleId]= $meta;
50		$this->topValues [$this->sampleId]= $value;
51		++$this->topCount;
52
53		if ($this->topCount > $this->captureTopItems) {
54		arsort($this->topValues);
55		end($this->topValues);
56		$sampleId = key($this->topValues);
57		unset($this->topValues[$sampleId]);
58		unset($this->topMetas[$sampleId]);
59		--$this->topCount;
60		}
61		}
62		}
63
64
65		if ($this->captureBottomItems) {
66		if ($this->bottomCount < $this->captureBottomItems \|\| $this->bottomLast === null \|\| $this->bottomLast > $value) {
67		++$this->sampleId;
68		$this->bottomMetas [$this->sampleId]= $meta;
69		$this->bottomValues [$this->sampleId]= $value;
70		++$this->bottomCount;
71
72		if ($this->bottomCount > $this->captureBottomItems) {
73		asort($this->bottomValues);
74		end($this->bottomValues);
75		$sampleId = key($this->bottomValues);
76		unset($this->bottomValues[$sampleId]);
77		unset($this->bottomMetas[$sampleId]);
78		--$this->bottomCount;
79		}
80		}
81		}
82
83
84		if (null === $this->buckets) {
85		$this->buckets = array(array($value, $value, 1, $meta));
86		$this->min = $this->max = $value;
87		$this->totalBuckets = 1;
88		}
89		else {
90		if ($value < $this->min) {
91		$this->min = $value;
92		array_unshift($this->buckets, array($value, $value, 1, $meta));
93		$this->totalBuckets++;
94		}
95		elseif ($value > $this->max) {
96		$this->max = $value;
97		array_push($this->buckets, array($value, $value, 1, $meta));
98		$this->totalBuckets++;
99		}
100		elseif ($value === $this->min) {
101		++$this->buckets[0][2];
102		}
103		elseif ($value === $this->max) {
104		++$this->buckets[$this->totalBuckets - 1][2];
105		}
106		else {
107		$this->insert($value, $meta);
108		}
109		}
110
111		if ($this->totalBuckets > $this->maxBuckets) {
112		$this->shrink();
113		}
114		}
115
116		private function insert($value, $meta = false) {
117		$left = 0;
118		$right = $this->totalBuckets - 1;
119		while ($right - $left > 0) {
120		$position = (int)(($right + $left)/2);
121		$item = $this->buckets[$position];
122		if ($value < $item[0]) {
123		$right = $position - 1;
124		}
125		elseif ($value > $item[1]) {
126		$left = $position + 1;
127		}
128		else {
129		++$this->buckets[$position][2];
130		return;
131		}
132		}
133
134		$position = $left;
135		$item = $this->buckets[$position];
136		if ($value < $item[0]) {
137		array_splice($this->buckets, $position, 0, array(array($value, $value, 1, $meta)));
138		++$this->totalBuckets;
139		}
140		elseif ($value > $item[1]) {
141		array_splice($this->buckets, $position + 1, 0, array(array($value, $value, 1, $meta)));
142		++$this->totalBuckets;
143		}
144		else {
145		++$this->buckets[$position][2];
146		}
147		}
148
149
150		private function shrink() {
151		$minPosition = 0;
152		$minCount = $this->buckets[$minPosition][2];
153		$mergePosition = 1;
154		$mergeCount = $this->buckets[$mergePosition][2];
155
156		for ($position = 1; $position < $this->totalBuckets; ++$position) {
157		$currentCount = $this->buckets[$position][2];
158		if ($position === $this->totalBuckets - 1) {
159		$currentMergePosition = $position - 1;
160		}
161		else {
162		$currentMergePosition = $this->buckets[$position + 1][2] < $this->buckets[$position - 1][2]
163		? $position + 1
164		: $position - 1;
165		}
166		$currentMergeCount = $this->buckets[$currentMergePosition][2];
167		if ($currentCount < $minCount
168		\|\| ($currentCount === $minCount
169		&& $currentMergeCount < $mergeCount)) {
170		$minPosition = $position;
171		$minCount = $currentCount;
172		$mergePosition = $currentMergePosition;
173		$mergeCount = $currentMergeCount;
174		}
175		}
176
177		if ($mergePosition > $minPosition) {
178		$this->buckets[$minPosition][1] = $this->buckets[$mergePosition][1];
179		}
180		else {
181		$this->buckets[$minPosition][0] = $this->buckets[$mergePosition][0];
182		}
183		$this->buckets[$minPosition][2] += $this->buckets[$mergePosition][2];
184		unset($this->buckets[$mergePosition]);
185		$this->buckets = array_values($this->buckets);
186		$this->totalBuckets--;
187		}
188
189
190	View Code Duplication	public function bottomPercentile($percentile = 0.9) {
		0 ignored issues – show Duplication introduced 2018-11-29 20:08 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
191		$currentCount = 0;
192		$percentileCount = $this->totalCount * $percentile;
193		$bucket = array(0, 0, 0);
194		for ($i = 0; $i < $this->totalBuckets; ++$i) {
195		$bucket = $this->buckets[$i];
196		$currentCount += $bucket[2];
197		if ($currentCount >= $percentileCount) {
198		return $bucket[1];
199		}
200		}
201		return $bucket[1];
202		}
203
204	View Code Duplication	public function topPercentile($percentile = 0.9) {
		0 ignored issues – show Duplication introduced 2018-11-29 20:08 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
205		$currentCount = 0;
206		$percentileCount = $this->totalCount * $percentile;
207		$bucket = array(0, 0, 0);
208		for ($i = $this->totalBuckets - 1; $i >= 0; --$i) {
209		$bucket = $this->buckets[$i];
210		$currentCount += $bucket[2];
211		if ($currentCount >= $percentileCount) {
212		return $bucket[0];
213		}
214		}
215		return $bucket[0];
216		}
217
218		public function getTopValues() {
219		return array_values($this->topValues);
220		}
221
222		public function getTopMetas() {
223		$result = array();
224		foreach ($this->topValues as $sampleId => $tmp) {
225		$result []= $this->topMetas[$sampleId];
226		}
227		return $result;
228		}
229
230		public function getBottomValues() {
231		return array_values($this->bottomValues);
232		}
233
234		public function getBottomMetas() {
235		$result = array();
236		foreach ($this->bottomValues as $sampleId => $tmp) {
237		$result []= $this->bottomMetas[$sampleId];
238		}
239		return $result;
240		}
241
242		}

phperf / percentiller

Percentiller::insert() B last analyzed 2018-11-29 20:08 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Percentiller::insert() B
last analyzed 2018-11-29 20:08 UTC