HTMLPurifier_UnitConverter::add() - Code Metrics - Hannesalm/EventCalendar - Measure and Improve Code Quality continuously with Scrutinizer

HTMLPurifier_UnitConverter::add() A
last analyzed 2016-06-19 14:11 UTC

↳ Parent: HTMLPurifier_UnitConverter

Complexity

Conditions	2
Paths	2

Size

Total Lines	8
Code Lines	5

Duplication

Lines	8
Ratio	100 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	2
eloc	5
c	1
b	0
f	0
nc	2
nop	3
dl	8
loc	8
rs	9.4285

<?php

/**
 * Class for converting between different unit-lengths as specified by
 * CSS.
 */
class HTMLPurifier_UnitConverter
namespace YourVendor;

class YourClass { }
{

    const ENGLISH = 1;
    const METRIC = 2;
    const DIGITAL = 3;

    /**
     * Units information array. Units are grouped into measuring systems
     * (English, Metric), and are assigned an integer representing
     * the conversion factor between that unit and the smallest unit in
     * the system. Numeric indexes are actually magical constants that
     * encode conversion data from one system to the next, with a O(n^2)
     * constraint on memory (this is generally not a problem, since
     * the number of measuring systems is small.)
     */
    protected static $units = array(
        self::ENGLISH => array(
            'px' => 3, // This is as per CSS 2.1 and Firefox. Your mileage may vary
            'pt' => 4,
            'pc' => 48,
            'in' => 288,
            self::METRIC => array('pt', '0.352777778', 'mm'),
        ),
        self::METRIC => array(
            'mm' => 1,
            'cm' => 10,
            self::ENGLISH => array('mm', '2.83464567', 'pt'),
        ),
    );

    /**
     * Minimum bcmath precision for output.
     * @type int
     */
    protected $outputPrecision;

    /**
     * Bcmath precision for internal calculations.
     * @type int
     */
    protected $internalPrecision;

    /**
     * Whether or not BCMath is available.
     * @type bool
     */
    private $bcmath;

    public function __construct($output_precision = 4, $internal_precision = 10, $force_no_bcmath = false)
    {
        $this->outputPrecision = $output_precision;
        $this->internalPrecision = $internal_precision;
        $this->bcmath = !$force_no_bcmath && function_exists('bcmul');
    }

    /**
     * Converts a length object of one unit into another unit.
     * @param HTMLPurifier_Length $length
     *      Instance of HTMLPurifier_Length to convert. You must validate()
     *      it before passing it here!
     * @param string $to_unit
     *      Unit to convert to.
     * @return HTMLPurifier_Length|bool
     * @note
     *      About precision: This conversion function pays very special
     *      attention to the incoming precision of values and attempts
     *      to maintain a number of significant figure. Results are
     *      fairly accurate up to nine digits. Some caveats:
     *          - If a number is zero-padded as a result of this significant
     *            figure tracking, the zeroes will be eliminated.
     *          - If a number contains less than four sigfigs ($outputPrecision)
     *            and this causes some decimals to be excluded, those
     *            decimals will be added on.
     */
    public function convert($length, $to_unit)
    {
        if (!$length->isValid()) {
            return false;
        }

        $n = $length->getN();
        $unit = $length->getUnit();

        if ($n === '0' || $unit === false) {
            return new HTMLPurifier_Length('0', false);
        }

        $state = $dest_state = false;
        foreach (self::$units as $k => $x) {
            if (isset($x[$unit])) {
                $state = $k;
            }
            if (isset($x[$to_unit])) {
                $dest_state = $k;
            }
        }
        if (!$state || !$dest_state) {
            return false;
        }

        // Some calculations about the initial precision of the number;
        // this will be useful when we need to do final rounding.
        $sigfigs = $this->getSigFigs($n);
        if ($sigfigs < $this->outputPrecision) {
            $sigfigs = $this->outputPrecision;
        }

        // BCMath's internal precision deals only with decimals. Use
        // our default if the initial number has no decimals, or increase
        // it by how ever many decimals, thus, the number of guard digits
        // will always be greater than or equal to internalPrecision.
        $log = (int)floor(log(abs($n), 10));
        $cp = ($log < 0) ? $this->internalPrecision - $log : $this->internalPrecision; // internal precision

        for ($i = 0; $i < 2; $i++) {

            // Determine what unit IN THIS SYSTEM we need to convert to
            if ($dest_state === $state) {
                // Simple conversion
                $dest_unit = $to_unit;
            } else {
                // Convert to the smallest unit, pending a system shift
                $dest_unit = self::$units[$state][$dest_state][0];
            }

            // Do the conversion if necessary
            if ($dest_unit !== $unit) {
                $factor = $this->div(self::$units[$state][$unit], self::$units[$state][$dest_unit], $cp);
                $n = $this->mul($n, $factor, $cp);
                $unit = $dest_unit;
            }

            // Output was zero, so bail out early. Shouldn't ever happen.
            if ($n === '') {
                $n = '0';
                $unit = $to_unit;
                break;
            }

            // It was a simple conversion, so bail out
            if ($dest_state === $state) {
                break;
            }

            if ($i !== 0) {
                // Conversion failed! Apparently, the system we forwarded
                // to didn't have this unit. This should never happen!
                return false;
            }

            // Pre-condition: $i == 0

            // Perform conversion to next system of units
            $n = $this->mul($n, self::$units[$state][$dest_state][1], $cp);
            $unit = self::$units[$state][$dest_state][2];
            $state = $dest_state;

            // One more loop around to convert the unit in the new system.

        }

        // Post-condition: $unit == $to_unit
        if ($unit !== $to_unit) {
            return false;
        }

        // Useful for debugging:
        //echo "<pre>n";
        //echo "$n\nsigfigs = $sigfigs\nnew_log = $new_log\nlog = $log\nrp = $rp\n</pre>\n";

        $n = $this->round($n, $sigfigs);
        if (strpos($n, '.') !== false) {
            $n = rtrim($n, '0');
        }
        $n = rtrim($n, '.');

        return new HTMLPurifier_Length($n, $unit);
    }

    /**
     * Returns the number of significant figures in a string number.
     * @param string $n Decimal number
     * @return int number of sigfigs
     */
    public function getSigFigs($n)
    {
        $n = ltrim($n, '0+-');
        $dp = strpos($n, '.'); // decimal position
        if ($dp === false) {
            $sigfigs = strlen(rtrim($n, '0'));
        } else {
            $sigfigs = strlen(ltrim($n, '0.')); // eliminate extra decimal character
            if ($dp !== 0) {
                $sigfigs--;
            }
        }
        return $sigfigs;
    }

    /**
     * Adds two numbers, using arbitrary precision when available.
     * @param string $s1
     * @param string $s2
     * @param int $scale
     * @return string
     */
    private function add($s1, $s2, $scale)

    {
        if ($this->bcmath) {
            return bcadd($s1, $s2, $scale);
        } else {
            return $this->scale((float)$s1 + (float)$s2, $scale);
        }
    }

    /**
     * Multiples two numbers, using arbitrary precision when available.
     * @param string $s1
     * @param string $s2
     * @param int $scale
     * @return string
     */
    private function mul($s1, $s2, $scale)

    {
        if ($this->bcmath) {
            return bcmul($s1, $s2, $scale);
        } else {
            return $this->scale((float)$s1 * (float)$s2, $scale);
        }
    }

    /**
     * Divides two numbers, using arbitrary precision when available.
     * @param string $s1
     * @param string $s2
     * @param int $scale
     * @return string
     */
    private function div($s1, $s2, $scale)

    {
        if ($this->bcmath) {
            return bcdiv($s1, $s2, $scale);
        } else {
            return $this->scale((float)$s1 / (float)$s2, $scale);
        }
    }

    /**
     * Rounds a number according to the number of sigfigs it should have,
     * using arbitrary precision when available.
     * @param float $n
     * @param int $sigfigs
     * @return string
     */
    private function round($n, $sigfigs)
    {
        $new_log = (int)floor(log(abs($n), 10)); // Number of digits left of decimal - 1
        $rp = $sigfigs - $new_log - 1; // Number of decimal places needed
        $neg = $n < 0 ? '-' : ''; // Negative sign
        if ($this->bcmath) {
            if ($rp >= 0) {
                $n = bcadd($n, $neg . '0.' . str_repeat('0', $rp) . '5', $rp + 1);
                $n = bcdiv($n, '1', $rp);
            } else {
                // This algorithm partially depends on the standardized
                // form of numbers that comes out of bcmath.
                $n = bcadd($n, $neg . '5' . str_repeat('0', $new_log - $sigfigs), 0);
                $n = substr($n, 0, $sigfigs + strlen($neg)) . str_repeat('0', $new_log - $sigfigs + 1);
            }
            return $n;
        } else {
            return $this->scale(round($n, $sigfigs - $new_log - 1), $rp + 1);
        }
    }

    /**
     * Scales a float to $scale digits right of decimal point, like BCMath.
     * @param float $r
     * @param int $scale
     * @return string
     */
    private function scale($r, $scale)
    {
        if ($scale < 0) {
            // The f sprintf type doesn't support negative numbers, so we
            // need to cludge things manually. First get the string.
            $r = sprintf('%.0f', (float)$r);
            // Due to floating point precision loss, $r will more than likely
            // look something like 4652999999999.9234. We grab one more digit
            // than we need to precise from $r and then use that to round
            // appropriately.
            $precise = (string)round(substr($r, 0, strlen($r) + $scale), -1);
            // Now we return it, truncating the zero that was rounded off.
            return substr($precise, 0, -1) . str_repeat('0', -$scale + 1);
        }
        return sprintf('%.' . $scale . 'f', (float)$r);
    }
}

// vim: et sw=4 sts=4


1		<?php
2
3		/**
4		* Class for converting between different unit-lengths as specified by
5		* CSS.
6		*/
7		class HTMLPurifier_UnitConverter
		0 ignored issues – show Coding Style Compatibility introduced 2016-06-19 13:37 UTC by Report Bug Copy Issue Report PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions. You can fix this by adding a namespace to your class: namespace YourVendor; class YourClass { } When choosing a vendor namespace, try to pick something that is not too generic to avoid conflicts with other libraries. Loading history...
8		{
9
10		const ENGLISH = 1;
11		const METRIC = 2;
12		const DIGITAL = 3;
13
14		/**
15		* Units information array. Units are grouped into measuring systems
16		* (English, Metric), and are assigned an integer representing
17		* the conversion factor between that unit and the smallest unit in
18		* the system. Numeric indexes are actually magical constants that
19		* encode conversion data from one system to the next, with a O(n^2)
20		* constraint on memory (this is generally not a problem, since
21		* the number of measuring systems is small.)
22		*/
23		protected static $units = array(
24		self::ENGLISH => array(
25		'px' => 3, // This is as per CSS 2.1 and Firefox. Your mileage may vary
26		'pt' => 4,
27		'pc' => 48,
28		'in' => 288,
29		self::METRIC => array('pt', '0.352777778', 'mm'),
30		),
31		self::METRIC => array(
32		'mm' => 1,
33		'cm' => 10,
34		self::ENGLISH => array('mm', '2.83464567', 'pt'),
35		),
36		);
37
38		/**
39		* Minimum bcmath precision for output.
40		* @type int
41		*/
42		protected $outputPrecision;
43
44		/**
45		* Bcmath precision for internal calculations.
46		* @type int
47		*/
48		protected $internalPrecision;
49
50		/**
51		* Whether or not BCMath is available.
52		* @type bool
53		*/
54		private $bcmath;
55
56		public function __construct($output_precision = 4, $internal_precision = 10, $force_no_bcmath = false)
57		{
58		$this->outputPrecision = $output_precision;
59		$this->internalPrecision = $internal_precision;
60		$this->bcmath = !$force_no_bcmath && function_exists('bcmul');
61		}
62
63		/**
64		* Converts a length object of one unit into another unit.
65		* @param HTMLPurifier_Length $length
66		* Instance of HTMLPurifier_Length to convert. You must validate()
67		* it before passing it here!
68		* @param string $to_unit
69		* Unit to convert to.
70		* @return HTMLPurifier_Length\|bool
71		* @note
72		* About precision: This conversion function pays very special
73		* attention to the incoming precision of values and attempts
74		* to maintain a number of significant figure. Results are
75		* fairly accurate up to nine digits. Some caveats:
76		* - If a number is zero-padded as a result of this significant
77		* figure tracking, the zeroes will be eliminated.
78		* - If a number contains less than four sigfigs ($outputPrecision)
79		* and this causes some decimals to be excluded, those
80		* decimals will be added on.
81		*/
82		public function convert($length, $to_unit)
83		{
84		if (!$length->isValid()) {
85		return false;
86		}
87
88		$n = $length->getN();
89		$unit = $length->getUnit();
90
91		if ($n === '0' \|\| $unit === false) {
92		return new HTMLPurifier_Length('0', false);
93		}
94
95		$state = $dest_state = false;
96		foreach (self::$units as $k => $x) {
97		if (isset($x[$unit])) {
98		$state = $k;
99		}
100		if (isset($x[$to_unit])) {
101		$dest_state = $k;
102		}
103		}
104		if (!$state \|\| !$dest_state) {
105		return false;
106		}
107
108		// Some calculations about the initial precision of the number;
109		// this will be useful when we need to do final rounding.
110		$sigfigs = $this->getSigFigs($n);
111		if ($sigfigs < $this->outputPrecision) {
112		$sigfigs = $this->outputPrecision;
113		}
114
115		// BCMath's internal precision deals only with decimals. Use
116		// our default if the initial number has no decimals, or increase
117		// it by how ever many decimals, thus, the number of guard digits
118		// will always be greater than or equal to internalPrecision.
119		$log = (int)floor(log(abs($n), 10));
120		$cp = ($log < 0) ? $this->internalPrecision - $log : $this->internalPrecision; // internal precision
121
122		for ($i = 0; $i < 2; $i++) {
123
124		// Determine what unit IN THIS SYSTEM we need to convert to
125		if ($dest_state === $state) {
126		// Simple conversion
127		$dest_unit = $to_unit;
128		} else {
129		// Convert to the smallest unit, pending a system shift
130		$dest_unit = self::$units[$state][$dest_state][0];
131		}
132
133		// Do the conversion if necessary
134		if ($dest_unit !== $unit) {
135		$factor = $this->div(self::$units[$state][$unit], self::$units[$state][$dest_unit], $cp);
136		$n = $this->mul($n, $factor, $cp);
137		$unit = $dest_unit;
138		}
139
140		// Output was zero, so bail out early. Shouldn't ever happen.
141		if ($n === '') {
142		$n = '0';
143		$unit = $to_unit;
144		break;
145		}
146
147		// It was a simple conversion, so bail out
148		if ($dest_state === $state) {
149		break;
150		}
151
152		if ($i !== 0) {
153		// Conversion failed! Apparently, the system we forwarded
154		// to didn't have this unit. This should never happen!
155		return false;
156		}
157
158		// Pre-condition: $i == 0
159
160		// Perform conversion to next system of units
161		$n = $this->mul($n, self::$units[$state][$dest_state][1], $cp);
162		$unit = self::$units[$state][$dest_state][2];
163		$state = $dest_state;
164
165		// One more loop around to convert the unit in the new system.
166
167		}
168
169		// Post-condition: $unit == $to_unit
170		if ($unit !== $to_unit) {
171		return false;
172		}
173
174		// Useful for debugging:
175		//echo "<pre>n";
176		//echo "$n\nsigfigs = $sigfigs\nnew_log = $new_log\nlog = $log\nrp = $rp\n</pre>\n";
177
178		$n = $this->round($n, $sigfigs);
179		if (strpos($n, '.') !== false) {
180		$n = rtrim($n, '0');
181		}
182		$n = rtrim($n, '.');
183
184		return new HTMLPurifier_Length($n, $unit);
185		}
186
187		/**
188		* Returns the number of significant figures in a string number.
189		* @param string $n Decimal number
190		* @return int number of sigfigs
191		*/
192		public function getSigFigs($n)
193		{
194		$n = ltrim($n, '0+-');
195		$dp = strpos($n, '.'); // decimal position
196		if ($dp === false) {
197		$sigfigs = strlen(rtrim($n, '0'));
198		} else {
199		$sigfigs = strlen(ltrim($n, '0.')); // eliminate extra decimal character
200		if ($dp !== 0) {
201		$sigfigs--;
202		}
203		}
204		return $sigfigs;
205		}
206
207		/**
208		* Adds two numbers, using arbitrary precision when available.
209		* @param string $s1
210		* @param string $s2
211		* @param int $scale
212		* @return string
213		*/
214	View Code Duplication	private function add($s1, $s2, $scale)
		0 ignored issues – show Unused Code introduced 2016-06-19 13:37 UTC by Report Bug Copy Issue Report This method is not used, and could be removed. Loading history... Duplication introduced 2016-06-19 13:37 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...
215		{
216		if ($this->bcmath) {
217		return bcadd($s1, $s2, $scale);
218		} else {
219		return $this->scale((float)$s1 + (float)$s2, $scale);
220		}
221		}
222
223		/**
224		* Multiples two numbers, using arbitrary precision when available.
225		* @param string $s1
226		* @param string $s2
227		* @param int $scale
228		* @return string
229		*/
230	View Code Duplication	private function mul($s1, $s2, $scale)
		0 ignored issues – show Duplication introduced 2016-06-19 13:37 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...
231		{
232		if ($this->bcmath) {
233		return bcmul($s1, $s2, $scale);
234		} else {
235		return $this->scale((float)$s1 * (float)$s2, $scale);
236		}
237		}
238
239		/**
240		* Divides two numbers, using arbitrary precision when available.
241		* @param string $s1
242		* @param string $s2
243		* @param int $scale
244		* @return string
245		*/
246	View Code Duplication	private function div($s1, $s2, $scale)
		0 ignored issues – show Duplication introduced 2016-06-19 13:37 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...
247		{
248		if ($this->bcmath) {
249		return bcdiv($s1, $s2, $scale);
250		} else {
251		return $this->scale((float)$s1 / (float)$s2, $scale);
252		}
253		}
254
255		/**
256		* Rounds a number according to the number of sigfigs it should have,
257		* using arbitrary precision when available.
258		* @param float $n
259		* @param int $sigfigs
260		* @return string
261		*/
262		private function round($n, $sigfigs)
263		{
264		$new_log = (int)floor(log(abs($n), 10)); // Number of digits left of decimal - 1
265		$rp = $sigfigs - $new_log - 1; // Number of decimal places needed
266		$neg = $n < 0 ? '-' : ''; // Negative sign
267		if ($this->bcmath) {
268		if ($rp >= 0) {
269		$n = bcadd($n, $neg . '0.' . str_repeat('0', $rp) . '5', $rp + 1);
270		$n = bcdiv($n, '1', $rp);
271		} else {
272		// This algorithm partially depends on the standardized
273		// form of numbers that comes out of bcmath.
274		$n = bcadd($n, $neg . '5' . str_repeat('0', $new_log - $sigfigs), 0);
275		$n = substr($n, 0, $sigfigs + strlen($neg)) . str_repeat('0', $new_log - $sigfigs + 1);
276		}
277		return $n;
278		} else {
279		return $this->scale(round($n, $sigfigs - $new_log - 1), $rp + 1);
280		}
281		}
282
283		/**
284		* Scales a float to $scale digits right of decimal point, like BCMath.
285		* @param float $r
286		* @param int $scale
287		* @return string
288		*/
289		private function scale($r, $scale)
290		{
291		if ($scale < 0) {
292		// The f sprintf type doesn't support negative numbers, so we
293		// need to cludge things manually. First get the string.
294		$r = sprintf('%.0f', (float)$r);
295		// Due to floating point precision loss, $r will more than likely
296		// look something like 4652999999999.9234. We grab one more digit
297		// than we need to precise from $r and then use that to round
298		// appropriately.
299		$precise = (string)round(substr($r, 0, strlen($r) + $scale), -1);
300		// Now we return it, truncating the zero that was rounded off.
301		return substr($precise, 0, -1) . str_repeat('0', -$scale + 1);
302		}
303		return sprintf('%.' . $scale . 'f', (float)$r);
304		}
305		}
306
307		// vim: et sw=4 sts=4
308

Hannesalm / EventCalendar

GitHub Access Token became invalid

HTMLPurifier_UnitConverter::add() A last analyzed 2016-06-19 14:11 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

HTMLPurifier_UnitConverter::add() A
last analyzed 2016-06-19 14:11 UTC