File indexing completed on 2024-05-12 06:02:47

 <?php
 /**
  * Zend Framework
  *
  * LICENSE
  *
  * This source file is subject to the new BSD license that is bundled
  * with this package in the file LICENSE.txt.
  * It is also available through the world-wide-web at this URL:
  * http://framework.zend.com/license/new-bsd
  * If you did not receive a copy of the license and are unable to
  * obtain it through the world-wide-web, please send an email
  * to license@zend.com so we can send you a copy immediately.
  *
  * @category  Zend
  * @package   Zend_Measure
  * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
  * @license   http://framework.zend.com/license/new-bsd     New BSD License
  * @version   $Id$
  */
 
 /**
  * Implement needed classes
  */
 // require_once 'Zend/Measure/Abstract.php';
 // require_once 'Zend/Locale.php';
 
 /**
  * Class for handling number conversions
  *
  * This class can only handle numbers without precision
  *
  * @category   Zend
  * @package    Zend_Measure
  * @subpackage Zend_Measure_Number
  * @copyright  Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
  * @license    http://framework.zend.com/license/new-bsd     New BSD License
  */
 class Zend_Measure_Number extends Zend_Measure_Abstract
 {
     const STANDARD = 'DECIMAL';
 
     const BINARY      = 'BINARY';
     const TERNARY     = 'TERNARY';
     const QUATERNARY  = 'QUATERNARY';
     const QUINARY     = 'QUINARY';
     const SENARY      = 'SENARY';
     const SEPTENARY   = 'SEPTENARY';
     const OCTAL       = 'OCTAL';
     const NONARY      = 'NONARY';
     const DECIMAL     = 'DECIMAL';
     const DUODECIMAL  = 'DUODECIMAL';
     const HEXADECIMAL = 'HEXADECIMAL';
     const ROMAN       = 'ROMAN';
 
     /**
      * Calculations for all number units
      *
      * @var array
      */
     protected $_units = array(
         'BINARY'      => array(2,  '⑵'),
         'TERNARY'     => array(3,  '⑶'),
         'QUATERNARY'  => array(4,  '⑷'),
         'QUINARY'     => array(5,  '⑸'),
         'SENARY'      => array(6,  '⑹'),
         'SEPTENARY'   => array(7,  '⑺'),
         'OCTAL'       => array(8,  '⑻'),
         'NONARY'      => array(9,  '⑼'),
         'DECIMAL'     => array(10, '⑽'),
         'DUODECIMAL'  => array(12, '⑿'),
         'HEXADECIMAL' => array(16, '⒃'),
         'ROMAN'       => array(99, ''),
         'STANDARD'    => 'DECIMAL'
     );
 
     /**
      * Definition of all roman signs
      *
      * @var array $_roman
      */
     private static $_roman = array(
         'I' => 1,
         'A' => 4,
         'V' => 5,
         'B' => 9,
         'X' => 10,
         'E' => 40,
         'L' => 50,
         'F' => 90,
         'C' => 100,
         'G' => 400,
         'D' => 500,
         'H' => 900,
         'M' => 1000,
         'J' => 4000,
         'P' => 5000,
         'K' => 9000,
         'Q' => 10000,
         'N' => 40000,
         'R' => 50000,
         'W' => 90000,
         'S' => 100000,
         'Y' => 400000,
         'T' => 500000,
         'Z' => 900000,
         'U' => 1000000
     );
 
     /**
      * Convertion table for roman signs
      *
      * @var array $_romanconvert
      */
     private static $_romanconvert = array(
         '/_V/' => '/P/',
         '/_X/' => '/Q/',
         '/_L/' => '/R/',
         '/_C/' => '/S/',
         '/_D/' => '/T/',
         '/_M/' => '/U/',
         '/IV/' => '/A/',
         '/IX/' => '/B/',
         '/XL/' => '/E/',
         '/XC/' => '/F/',
         '/CD/' => '/G/',
         '/CM/' => '/H/',
         '/M_V/'=> '/J/',
         '/MQ/' => '/K/',
         '/QR/' => '/N/',
         '/QS/' => '/W/',
         '/ST/' => '/Y/',
         '/SU/' => '/Z/'
     );
 
     /**
      * Zend_Measure_Abstract is an abstract class for the different measurement types
      *
      * @param  integer            $value  Value
      * @param  string             $type   (Optional) A Zend_Measure_Number Type
      * @param  string|Zend_Locale $locale (Optional) A Zend_Locale
      * @throws Zend_Measure_Exception When language is unknown
      * @throws Zend_Measure_Exception When type is unknown
      */
     public function __construct($value, $type, $locale = null)
     {
         if (($type !== null) and (Zend_Locale::isLocale($type, null, false))) {
             $locale = $type;
             $type = null;
         }
 
         if ($locale === null) {
             $locale = new Zend_Locale();
         }
 
         if (!Zend_Locale::isLocale($locale, true, false)) {
             if (!Zend_Locale::isLocale($locale, true, false)) {
                 // require_once 'Zend/Measure/Exception.php';
                 throw new Zend_Measure_Exception("Language (" . (string) $locale . ") is unknown");
             }
 
             $locale = new Zend_Locale($locale);
         }
 
         $this->_locale = (string) $locale;
 
         if ($type === null) {
             $type = $this->_units['STANDARD'];
         }
 
         if (isset($this->_units[$type]) === false) {
             // require_once 'Zend/Measure/Exception.php';
             throw new Zend_Measure_Exception("Type ($type) is unknown");
         }
 
         $this->setValue($value, $type, $this->_locale);
     }
 
     /**
      * Set a new value
      *
      * @param  integer            $value  Value
      * @param  string             $type   (Optional) A Zend_Measure_Number Type
      * @param  string|Zend_Locale $locale (Optional) A Zend_Locale Type
      * @throws Zend_Measure_Exception
      */
     public function setValue($value, $type = null, $locale = null)
     {
         if (empty($locale)) {
             $locale = $this->_locale;
         }
 
         if (empty($this->_units[$type])) {
             // require_once 'Zend/Measure/Exception.php';
             throw new Zend_Measure_Exception('unknown type of number:' . $type);
         }
 
         switch($type) {
             case 'BINARY':
                 preg_match('/[01]+/', $value, $ergebnis);
                 $value = $ergebnis[0];
                 break;
 
             case 'TERNARY':
                 preg_match('/[012]+/', $value, $ergebnis);
                 $value = $ergebnis[0];
                 break;
 
             case 'QUATERNARY':
                 preg_match('/[0123]+/', $value, $ergebnis);
                 $value = $ergebnis[0];
                 break;
 
             case 'QUINARY':
                 preg_match('/[01234]+/', $value, $ergebnis);
                 $value = $ergebnis[0];
                 break;
 
             case 'SENARY':
                 preg_match('/[012345]+/', $value, $ergebnis);
                 $value = $ergebnis[0];
                 break;
 
             case 'SEPTENARY':
                 preg_match('/[0123456]+/', $value, $ergebnis);
                 $value = $ergebnis[0];
                 break;
 
             case 'OCTAL':
                 preg_match('/[01234567]+/', $value, $ergebnis);
                 $value = $ergebnis[0];
                 break;
 
             case 'NONARY':
                 preg_match('/[012345678]+/', $value, $ergebnis);
                 $value = $ergebnis[0];
                 break;
 
             case 'DUODECIMAL':
                 preg_match('/[0123456789AB]+/', strtoupper($value), $ergebnis);
                 $value = $ergebnis[0];
                 break;
 
             case 'HEXADECIMAL':
                 preg_match('/[0123456789ABCDEF]+/', strtoupper($value), $ergebnis);
                 $value = $ergebnis[0];
                 break;
 
             case 'ROMAN':
                 preg_match('/[IVXLCDM_]+/', strtoupper($value), $ergebnis);
                 $value = $ergebnis[0];
                 break;
 
             default:
                 try {
                     $value = Zend_Locale_Format::getInteger($value, array('locale' => $locale));
                 } catch (Exception $e) {
                     // require_once 'Zend/Measure/Exception.php';
                     throw new Zend_Measure_Exception($e->getMessage(), $e->getCode(), $e);
                 }
                 if (call_user_func(Zend_Locale_Math::$comp, $value, 0) < 0) {
                     $value = call_user_func(Zend_Locale_Math::$sqrt, call_user_func(Zend_Locale_Math::$pow, $value, 2));
                 }
                 break;
         }
 
         $this->_value = $value;
         $this->_type  = $type;
     }
 
     /**
      * Convert input to decimal value string
      *
      * @param  integer $input Input string
      * @param  string  $type  Type from which to convert to decimal
      * @return string
      */
     private function _toDecimal($input, $type)
     {
         $value = '';
         // Convert base xx values
         if ($this->_units[$type][0] <= 16) {
             $split  = str_split($input);
             $length = strlen($input);
             for ($x = 0; $x < $length; ++$x) {
                 $split[$x] = hexdec($split[$x]);
                 $value     = call_user_func(Zend_Locale_Math::$add, $value,
                             call_user_func(Zend_Locale_Math::$mul, $split[$x],
                             call_user_func(Zend_Locale_Math::$pow, $this->_units[$type][0], ($length - $x - 1))));
             }
         }
 
         // Convert roman numbers
         if ($type === 'ROMAN') {
             $input = strtoupper($input);
             $input = preg_replace(array_keys(self::$_romanconvert), array_values(self::$_romanconvert), $input);
 
             $split = preg_split('//', strrev($input), -1, PREG_SPLIT_NO_EMPTY);
 
             for ($x =0; $x < sizeof($split); $x++) {
                 if ($split[$x] == '/') {
                     continue;
                 }
 
                 $num = self::$_roman[$split[$x]];
                 if (($x > 0 and ($split[$x-1] != '/') and ($num < self::$_roman[$split[$x-1]]))) {
                     $num -= $num;
                 }
 
                 $value += $num;
             }
 
             str_replace('/', '', $value);
         }
 
         return $value;
     }
 
     /**
      * Convert input to type value string
      *
      * @param  integer $value Input string
      * @param  string  $type  Type to convert to
      * @return string
      * @throws Zend_Measure_Exception When more than 200 digits are calculated
      */
     private function _fromDecimal($value, $type)
     {
         $tempvalue = $value;
         if ($this->_units[$type][0] <= 16) {
             $newvalue = '';
             $count    = 200;
             $base     = $this->_units[$type][0];
 
             while (call_user_func(Zend_Locale_Math::$comp, $value, 0, 25) <> 0) {
                 $target = call_user_func(Zend_Locale_Math::$mod, $value, $base);
 
                 $newvalue = strtoupper(dechex($target)) . $newvalue;
 
                 $value = call_user_func(Zend_Locale_Math::$sub, $value, $target, 0);
                 $value = call_user_func(Zend_Locale_Math::$div, $value, $base, 0);
 
                 --$count;
                 if ($count === 0) {
                     // require_once 'Zend/Measure/Exception.php';
                     throw new Zend_Measure_Exception("Your value '$tempvalue' cannot be processed because it extends 200 digits");
                 }
             }
 
             if ($newvalue === '') {
                 $newvalue = '0';
             }
         }
 
         if ($type === 'ROMAN') {
             $i        = 0;
             $newvalue = '';
             $romanval = array_values(array_reverse(self::$_roman));
             $romankey = array_keys(array_reverse(self::$_roman));
             $count    = 200;
             while (call_user_func(Zend_Locale_Math::$comp, $value, 0, 25) <> 0) {
                 while ($value >= $romanval[$i]) {
                     $value    -= $romanval[$i];
                     $newvalue .= $romankey[$i];
 
                     if ($value < 1) {
                         break;
                     }
 
                     --$count;
                     if ($count === 0) {
                         // require_once 'Zend/Measure/Exception.php';
                         throw new Zend_Measure_Exception("Your value '$tempvalue' cannot be processed because it extends 200 digits");
                     }
                 }
 
                 $i++;
             }
 
             $newvalue = str_replace('/', '', preg_replace(array_values(self::$_romanconvert), array_keys(self::$_romanconvert), $newvalue));
         }
 
         return $newvalue;
     }
 
     /**
      * Set a new type, and convert the value
      *
      * @param  string $type New type to set
      * @throws Zend_Measure_Exception When a unknown type is given
      * @return void
      */
     public function setType($type)
     {
         if (empty($this->_units[$type]) === true) {
             // require_once 'Zend/Measure/Exception.php';
             throw new Zend_Measure_Exception('Unknown type of number:' . $type);
         }
 
         $value = $this->_toDecimal($this->getValue(-1), $this->getType(-1));
         $value = $this->_fromDecimal($value, $type);
 
         $this->_value = $value;
         $this->_type  = $type;
     }
 
     /**
      * Alias function for setType returning the converted unit
      * Default is 0 as this class only handles numbers without precision
      *
      * @param  string  $type  Type to convert to
      * @param  integer $round (Optional) Precision to add, will always be 0
      * @return string
      */
     public function convertTo($type, $round = 0, $locale = null)
     {
         $this->setType($type);
 
         // Roman numerals do not need a formatting
         if ($this->getType() === self::ROMAN) {
             return $this->_value;
         }
 
         return $this->toString($round, $locale);
     }
 }