AbstractTable::getOpenStandard() - Code Metrics - Inspection of "add track tables and world records for 60m to 3000..." - Runalyze/age-grade - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( c91059...83bd3e )

by Hannes

created 2018-01-02 19:36 UTC

AbstractTable::getOpenStandard() A

↳ Parent: AbstractTable

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	1
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	4
ccs	1
cts	1
cp	1
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	0
crap	1

<?php

/*
 * This file is part of the Runalyze Age Grade.
 *
 * (c) RUNALYZE <[email protected]>
 *
 * This source file is subject to the MIT license that is bundled
 * with this source code in the file LICENSE.
 */

namespace Runalyze\AgeGrade\Table;

use Runalyze\AgeGrade\AgeGrade;

/**
 * Classes extending AbstractTable must provide correctly sized $OpenStandard and $AgeFactors.
 */
abstract class AbstractTable implements TableInterface
{
    /** @var int */
    protected $NumDistances;

    /** @var int */
    protected $NumAges;

    /** @var float[] available distances [km] */
    protected $Distances = [];

    /** @var int[] available ages [from, to] in [years] */
    protected $AgeRange = [5, 100];

    /** @var float[] open standard times for all available distances in [s] */
    protected $OpenStandard = [];

    /** @var float[] for each age an array with factors for all available distances in [0.0 .. 1.0] */
    protected $AgeFactors = [];

    public function __construct()
    {
        $this->NumDistances = count($this->Distances);
        $this->NumAges = 1 + $this->AgeRange[1] - $this->AgeRange[0];
    }

    /**
     * @return array distances with exact age standards [km]
     */
    public function getAvailableDistances()
    {
        return $this->Distances;
    }

    /**
     * @return float[] open standard times for all available distances in [s]
     */
    public function getOpenStandard()
    {
        return $this->OpenStandard;
    }

    /**
     * @return array [from, to] in [years]
     */
    public function getAvailableAgeRange()
    {
        return $this->AgeRange;
    }

    /**
     * @return float [km]
     */
    public function getMinimalDistance()
    {
        return $this->Distances[0];
    }

    /**
     * @param  int       $age           [years]
     * @param  float     $distance      [km]
     * @param  int|float $timeInSeconds [s]
     * @return float     age grade in [0.0 .. 1.0]
     */
    public function getAgePerformance($age, $distance, $timeInSeconds)
    {
        return $this->getAgeStandard($age, $distance) / $timeInSeconds;
    }

    /**
     * @param  int       $age           [years]
     * @param  float     $distance      [km]
     * @param  int|float $timeInSeconds [s]
     * @return AgeGrade
     */
    public function getAgeGrade($age, $distance, $timeInSeconds)
    {
        $ageStandard = $this->getAgeStandard($age, $distance);
        $ageFactor = $this->getAgeFactor($age, $distance);

        $ageGrade = new AgeGrade($ageStandard / $timeInSeconds);
        $ageGrade->setOriginalResult($distance, $timeInSeconds);
        $ageGrade->setTableData($ageStandard, $ageFactor);

        return $ageGrade;
    }

    /**
     * @param  int       $age      [years]
     * @param  float     $distance [km]
     * @return int|float age standard by WMA [s]
     */
    public function getAgeStandard($age, $distance)
    {
        list($distanceIndex, $fraction) = $this->getDistanceIndexWithFraction($distance);
        $ageFactor = $this->getAgeFactor($age, $distance);

        if (1.0 === $fraction) {
            return $this->OpenStandard[$distanceIndex] / $ageFactor;
        }

        return ((1 - $fraction) * $this->OpenStandard[$distanceIndex - 1] + $fraction * $this->OpenStandard[$distanceIndex]) / $ageFactor;
    }

    /**
     * @param  int   $age      [years]
     * @param  float $distance [km]
     * @return float age grade factor in [0.0 .. 1.0]
     */
    protected function getAgeFactor($age, $distance)
    {
        $ageIndex = $this->getAgeIndex($age);
        list($distanceIndex, $fraction) = $this->getDistanceIndexWithFraction($distance);

        if ($distance <= $this->Distances[0] || $distance >= $this->Distances[$this->NumDistances - 1]) {
            return $this->AgeFactors[$ageIndex][$distanceIndex];
        }

        return (1 - $fraction) * $this->AgeFactors[$ageIndex][$distanceIndex - 1] + $fraction * $this->AgeFactors[$ageIndex][$distanceIndex];
    }

    /**
     * @param  int $age [years]
     * @return int age index for internal table
     */
    protected function getAgeIndex($age)
    {
        list($min, $max) = $this->AgeRange;

        if ($age < $min) {
            $age = $min;
        } elseif ($age > $max) {
            $age = $max;
        }

        return (int) $age - $min;
    }

    /**
     * @param  float $distance [km]
     * @return array [index, fraction] distance index for internal table
     *                        fraction belongs to the returned index, (1 - fraction) to (index - 1)
     */
    protected function getDistanceIndexWithFraction($distance)
    {
        if ($distance <= $this->Distances[0]) {
            return [0, 1.0];
        }

        if ($distance >= $this->Distances[$this->NumDistances - 1]) {
            return [$this->NumDistances - 1, 1.0];
        }

        for ($i = 0; $i < $this->NumDistances; ++$i) {
            if ($this->Distances[$i] >= $distance) {
                break;
            }
        }

        $i = min($i, $this->NumDistances - 1);
        $fraction = ($distance - $this->Distances[$i - 1]) / ($this->Distances[$i] - $this->Distances[$i - 1]);

        return [$i, $fraction];
    }
}


1		<?php
2
3		/*
4		* This file is part of the Runalyze Age Grade.
5		*
6		* (c) RUNALYZE <[email protected]>
7		*
8		* This source file is subject to the MIT license that is bundled
9		* with this source code in the file LICENSE.
10		*/
11
12		namespace Runalyze\AgeGrade\Table;
13
14		use Runalyze\AgeGrade\AgeGrade;
15
16		/**
17		* Classes extending AbstractTable must provide correctly sized $OpenStandard and $AgeFactors.
18		*/
19		abstract class AbstractTable implements TableInterface
20		{
21		/** @var int */
22		protected $NumDistances;
23
24		/** @var int */
25		protected $NumAges;
26
27		/** @var float[] available distances [km] */
28		protected $Distances = [];
29
30		/** @var int[] available ages [from, to] in [years] */
31		protected $AgeRange = [5, 100];
32
33		/** @var float[] open standard times for all available distances in [s] */
34		protected $OpenStandard = [];
35
36		/** @var float[] for each age an array with factors for all available distances in [0.0 .. 1.0] */
37		protected $AgeFactors = [];
38
39		public function __construct()
40		{
41	15	$this->NumDistances = count($this->Distances);
42		$this->NumAges = 1 + $this->AgeRange[1] - $this->AgeRange[0];
43	15	}
44	15
45	15	/**
46		* @return array distances with exact age standards [km]
47		*/
48		public function getAvailableDistances()
49		{
50	1	return $this->Distances;
51		}
52	1
53		/**
54		* @return float[] open standard times for all available distances in [s]
55		*/
56		public function getOpenStandard()
57		{
58	1	return $this->OpenStandard;
59		}
60	1
61		/**
62		* @return array [from, to] in [years]
63		*/
64		public function getAvailableAgeRange()
65		{
66	1	return $this->AgeRange;
67		}
68	1
69		/**
70		* @return float [km]
71		*/
72		public function getMinimalDistance()
73		{
74		return $this->Distances[0];
75		}
76
77	7	/**
78		* @param int $age [years]
79	7	* @param float $distance [km]
80		* @param int\|float $timeInSeconds [s]
81		* @return float age grade in [0.0 .. 1.0]
82		*/
83		public function getAgePerformance($age, $distance, $timeInSeconds)
84		{
85		return $this->getAgeStandard($age, $distance) / $timeInSeconds;
86		}
87
88	2	/**
89		* @param int $age [years]
90	2	* @param float $distance [km]
91	2	* @param int\|float $timeInSeconds [s]
92		* @return AgeGrade
93	2	*/
94	2	public function getAgeGrade($age, $distance, $timeInSeconds)
95	2	{
96		$ageStandard = $this->getAgeStandard($age, $distance);
97	2	$ageFactor = $this->getAgeFactor($age, $distance);
98
99		$ageGrade = new AgeGrade($ageStandard / $timeInSeconds);
100		$ageGrade->setOriginalResult($distance, $timeInSeconds);
101		$ageGrade->setTableData($ageStandard, $ageFactor);
102
103		return $ageGrade;
104		}
105	11
106		/**
107	11	* @param int $age [years]
108	11	* @param float $distance [km]
109		* @return int\|float age standard by WMA [s]
110	11	*/
111	10	public function getAgeStandard($age, $distance)
112		{
113		list($distanceIndex, $fraction) = $this->getDistanceIndexWithFraction($distance);
114	3	$ageFactor = $this->getAgeFactor($age, $distance);
115
116		if (1.0 === $fraction) {
117		return $this->OpenStandard[$distanceIndex] / $ageFactor;
118		}
119
120		return ((1 - $fraction) * $this->OpenStandard[$distanceIndex - 1] + $fraction * $this->OpenStandard[$distanceIndex]) / $ageFactor;
121		}
122	11
123		/**
124	11	* @param int $age [years]
125	11	* @param float $distance [km]
126		* @return float age grade factor in [0.0 .. 1.0]
127	11	*/
128	6	protected function getAgeFactor($age, $distance)
129		{
130		$ageIndex = $this->getAgeIndex($age);
131	7	list($distanceIndex, $fraction) = $this->getDistanceIndexWithFraction($distance);
132
133		if ($distance <= $this->Distances[0] \|\| $distance >= $this->Distances[$this->NumDistances - 1]) {
134		return $this->AgeFactors[$ageIndex][$distanceIndex];
135		}
136
137		return (1 - $fraction) * $this->AgeFactors[$ageIndex][$distanceIndex - 1] + $fraction * $this->AgeFactors[$ageIndex][$distanceIndex];
138	11	}
139
140	11	/**
141		* @param int $age [years]
142	11	* @return int age index for internal table
143	1	*/
144	11	protected function getAgeIndex($age)
145	1	{
146	1	list($min, $max) = $this->AgeRange;
147
148	11	if ($age < $min) {
149		$age = $min;
150		} elseif ($age > $max) {
151		$age = $max;
152		}
153
154		return (int) $age - $min;
155		}
156	11
157		/**
158	11	* @param float $distance [km]
159	4	* @return array [index, fraction] distance index for internal table
160		* fraction belongs to the returned index, (1 - fraction) to (index - 1)
161		*/
162	11	protected function getDistanceIndexWithFraction($distance)
163	4	{
164		if ($distance <= $this->Distances[0]) {
165		return [0, 1.0];
166	7	}
167	7
168	7	if ($distance >= $this->Distances[$this->NumDistances - 1]) {
169		return [$this->NumDistances - 1, 1.0];
170	7	}
171
172	7	for ($i = 0; $i < $this->NumDistances; ++$i) {
173	7	if ($this->Distances[$i] >= $distance) {
174		break;
175	7	}
176		}
177
178		$i = min($i, $this->NumDistances - 1);
179		$fraction = ($distance - $this->Distances[$i - 1]) / ($this->Distances[$i] - $this->Distances[$i - 1]);
180
181		return [$i, $fraction];
182		}
183		}
184

Runalyze / age-grade

Push — master ( c91059...83bd3e )

AbstractTable::getOpenStandard() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like