ondrej-bouda / ivory

showcase/issues/mutability.php

Indentation +2 added lines, -2 removed lines

@@ -14,14 +14,14 @@
 // VERSION 1: mutable relations
 
 foreach ($personRel as $row) {
-	print_r($row); // prints just the 'id', 'firstname', and 'lastname' attributes
+    print_r($row); // prints just the 'id', 'firstname', and 'lastname' attributes
 }
 
 
 // VERSION 2: immutable relations
 
 foreach ($personRel as $row) {
-	print_r($row); // prints the whole person row, not just the three attributes
+    print_r($row); // prints the whole person row, not just the three attributes
 }
 
 // VERSION 2a: the project() and similar methods copy the entire object into a new one

showcase/issues/aliasing.php

Indentation +8 added lines, -8 removed lines

@@ -15,12 +15,12 @@ 
 $availPersonRel = new DbViewRelation('vw_avail_person', 'datatemplate');
 
 $sql = new StatementRelation(
-	"SELECT avail.room_id, %ln@p, 'the % sign is not expanded inside string literals'
+    "SELECT avail.room_id, %ln@p, 'the % sign is not expanded inside string literals'
 	 FROM % avail
 	      JOIN % p ON p.id = avail.person_id",
-	$personRel->project('id', 'firstname', 'lastname'),
-	$availPersonRel,
-	$personRel
+    $personRel->project('id', 'firstname', 'lastname'),
+    $availPersonRel,
+    $personRel
 );
 // "%ln" denotes a list of identifiers; in this case, it is fed with a relation, which causes to take all its attributes
 // the "@" sign denotes aliasing the relation of attributes
@@ -33,11 +33,11 @@ 
 $availPersonRel = new DbViewRelation('vw_avail_person', 'datatemplate');
 
 $sql = new StatementRelation(
-	"SELECT avail.room_id, %ln, 'the % sign is not expanded inside string literals'
+    "SELECT avail.room_id, %ln, 'the % sign is not expanded inside string literals'
 	 FROM %
 	      JOIN % ON p.id = avail.person_id",
-	$personRel->project('id', 'firstname', 'lastname'),
-	$availPersonRel->aliased('avail'),
-	$personRel
+    $personRel->project('id', 'firstname', 'lastname'),
+    $availPersonRel->aliased('avail'),
+    $personRel
 );
 // "%ln" denotes a list of identifiers; in this case, it is fed with a relation, which causes to take all its attributes

showcase/basic.php

Indentation +12 added lines, -12 removed lines

@@ -9,32 +9,32 @@
 $joesRel = $personRel->findWhere('firstname = %', 'Joe'); // the percent sign for no conversion - take "string"
 
 foreach ($joesRel as $row) {
-	printf("%s %s\n", $row['firstname'], $row['lastname']);
+    printf("%s %s\n", $row['firstname'], $row['lastname']);
 }
 
 $joesName = $joesRel->project(['firstname', 'lastname', 'dateofbirth']); // project() limits the attributes to be fetched only to the listed ones
 foreach ($joesName as $i => $row) {
-	printf("%d: %s %s, born on %s\n",
-		$i, $row['firstname'], $row['lastname'], $row['dateofbirth']->format('Y-m-d')
-	);
+    printf("%d: %s %s, born on %s\n",
+        $i, $row['firstname'], $row['lastname'], $row['dateofbirth']->format('Y-m-d')
+    );
 }
 
 $joeRows = $joesRel->map('id'); // fetch all columns, map by id
 foreach ($joeRows as $id => $row) {
-	printf("person #%d:\n", $id);
-	foreach ($row as $field => $value) {
-		printf("  %s => %s\n", $field, $value);
-	}
+    printf("person #%d:\n", $id);
+    foreach ($row as $field => $value) {
+        printf("  %s => %s\n", $field, $value);
+    }
 }
 
 $joesLastnameMap = $joesRel->map('id', 'lastname'); // fetch a map of person ids to lastnames
 foreach ($joesLastnameMap as $id => $lastname) {
-	printf("%d: %s\n", $id, $lastname);
+    printf("%d: %s\n", $id, $lastname);
 }
 
 $joesRowMap = $joesRel->map('id', ['firstname', 'lastname', 'dateofbirth']); // fetch a map of person ids to rows containing the person firstname, lastname, and date of birth
 foreach ($joesRowMap as $id => $row) {
-	printf("%d: %s %s, born on %s\n",
-		$id, $row['firstname'], $row['lastname'], $row['dateofbirth']->format('Y-m-d')
-	);
+    printf("%d: %s %s, born on %s\n",
+        $id, $row['firstname'], $row['lastname'], $row['dateofbirth']->format('Y-m-d')
+    );
 }

showcase/sql.php

Indentation +24 added lines, -24 removed lines

@@ -12,53 +12,53 @@
 $roomIds = [3, 4, 5];
 
 $sql = new StatementRelation(
-	"SELECT avail.room_id, %ln@p, 'the % sign is not expanded inside string literals'
+    "SELECT avail.room_id, %ln@p, 'the % sign is not expanded inside string literals'
 	 FROM % avail
 	      JOIN % p ON p.id = avail.person_id
 	 WHERE avail.room_id IN (%l) AND p.id IN (%l)
 	 ORDER BY avail.room_id, p.lastname, p.firstname",
-	$personRel->project('id', 'firstname', 'lastname'), // limit the person relation only to these attributes
-	$availPersonRel, // the real power comes in: any relation shall be applicable in the query
-	$personRel,
-	$roomIds, $employeeIds
+    $personRel->project('id', 'firstname', 'lastname'), // limit the person relation only to these attributes
+    $availPersonRel, // the real power comes in: any relation shall be applicable in the query
+    $personRel,
+    $roomIds, $employeeIds
 );
 // "%l" generally means a list of something; another formatting token may follow, specifying the list subtype
 // the list subtype may be omitted to use the identity conversion, just like for any argument
 // here, "%ln" denotes a list of identifiers; in this case, it is fed with a relation, which causes to take all its (three) attributes
 // the "@" sign denotes aliasing the relation of attributes
 foreach ($sql as $row) {
-	printf("%s %s available for room #%d\n", $row['firstname'], $row['lastname'], $row['room_id']);
+    printf("%s %s available for room #%d\n", $row['firstname'], $row['lastname'], $row['room_id']);
 }
 
 
 class PersonRole extends DbTableRelation
 {
-	public function __construct()
-	{
-		parent::__construct('person_role');
-	}
+    public function __construct()
+    {
+        parent::__construct('person_role');
+    }
 }
 
 class Role extends DbTableRelation
 {
-	const ADMIN = 1;
+    const ADMIN = 1;
 
-	public function __construct()
-	{
-		parent::__construct('role');
-	}
+    public function __construct()
+    {
+        parent::__construct('role');
+    }
 }
 
 $adminInfo = $personRel->project([
-	'id',
-	'fname' => 'firstname',
-	'lastname' => 'UPPER(lastname)',
-	'is_admin' => new Statement("EXISTS(SELECT 1 FROM %n WHERE role = %)", PersonRole::class, Role::ADMIN), // unfortunately, PHP implements ::class as mere string, not an object of a special class, thus, the explicit %n must be used
+    'id',
+    'fname' => 'firstname',
+    'lastname' => 'UPPER(lastname)',
+    'is_admin' => new Statement("EXISTS(SELECT 1 FROM %n WHERE role = %)", PersonRole::class, Role::ADMIN), // unfortunately, PHP implements ::class as mere string, not an object of a special class, thus, the explicit %n must be used
 ]);
 foreach ($adminInfo as $row) {
-	echo $row['fname'] . ' ' . $row['lastname'];
-	if ($row['is_admin']) {
-		echo ' is admin';
-	}
-	echo "\n";
+    echo $row['fname'] . ' ' . $row['lastname'];
+    if ($row['is_admin']) {
+        echo ' is admin';
+    }
+    echo "\n";
 }

showcase/exprs.php

Indentation +5 added lines, -5 removed lines

@@ -5,13 +5,13 @@
 use Ivory\Data\ValuesRelation;
 
 $valRel = new ValuesRelation([
-	[1, 'a', 3.14, true],
-	[5, 'g', 2.81, false],
+    [1, 'a', 3.14, true],
+    [5, 'g', 2.81, false],
 ]);
 $sel = new StatementRelation(
-	"SELECT * FROM % AS vals (num, letter, decim, flag) WHERE flag",
-	$valRel
+    "SELECT * FROM % AS vals (num, letter, decim, flag) WHERE flag",
+    $valRel
 );
 foreach ($sel as $row) {
-	printf("%d, %s, %f\n", $row['num'], $row['letter'], $row['decim']);
+    printf("%d, %s, %f\n", $row['num'], $row['letter'], $row['decim']);
 }

showcase/processing.php

Indentation +3 added lines, -3 removed lines

@@ -23,7 +23,7 @@ 
  * Hence the lessonperson.schedulingstatus attribute, holding enum values "scheduled" or "actual".
  */
 $rel = new StatementRelation(
-	'SELECT lesson.id AS lesson_id, lesson.name AS lesson_name,
+    'SELECT lesson.id AS lesson_id, lesson.name AS lesson_name,
             lp.schedulingstatus,
 	        p.id AS person_id, p.firstname AS person_firstname, p.lastname AS person_lastname,
 	        p.schedabbr AS person_schedabbr
@@ -31,7 +31,7 @@ 
 	      JOIN lessonperson lp ON lp.lesson_id = lesson.id
 	      JOIN person p ON p.id = lp.person_id
 	 WHERE lesson.actual_timerange && %',
-	new DateTimeRange(new \DateTime(), new \DateTime('+1 day'))
+    new DateTimeRange(new \DateTime(), new \DateTime('+1 day'))
 );
 
 // CASE 1; map: lesson ID => row
@@ -49,7 +49,7 @@ 
 
 // CASE 4; map: lesson ID => map: person ID => user function result
 $res = $rel->map('lesson_id')->map('person_id')->col(function ($row) {
-	return ($row['person_schedabbr'] ? : mb_substr($row['person_lastname'], 0, 4));
+    return ($row['person_schedabbr'] ? : mb_substr($row['person_lastname'], 0, 4));
 });
 var_dump($res[4][7]); // prints, e.g., "Brez", which is the scheduling abbreviation of person 7, who teaches in lesson 4
 

src/Ivory/Value/VarBitString.php

Indentation +56 added lines, -56 removed lines

@@ -17,66 +17,66 @@
  */
 class VarBitString extends BitString
 {
-	/** @var int|null */
-	private $maxLength;
+    /** @var int|null */
+    private $maxLength;
 
-	/**
-	 * @param string $bits the bit string, i.e., a string of 1's and 0's
-	 * @param int|null $maxLength maximal length of the bit string in bits;
-	 *                            <tt>null</tt> for no limit;
-	 *                            if less than <tt>strlen($bits)</tt>, the bits get truncated on the right and a warning
-	 *                              is issued
-	 * @return VarBitString
-	 * @throws \InvalidArgumentException if <tt>$length</tt> is a non-positive number (PostgreSQL forbids it)
-	 */
-	public static function fromString($bits, $maxLength = null)
-	{
-		$bits = (string)$bits;
+    /**
+     * @param string $bits the bit string, i.e., a string of 1's and 0's
+     * @param int|null $maxLength maximal length of the bit string in bits;
+     *                            <tt>null</tt> for no limit;
+     *                            if less than <tt>strlen($bits)</tt>, the bits get truncated on the right and a warning
+     *                              is issued
+     * @return VarBitString
+     * @throws \InvalidArgumentException if <tt>$length</tt> is a non-positive number (PostgreSQL forbids it)
+     */
+    public static function fromString($bits, $maxLength = null)
+    {
+        $bits = (string)$bits;
 
-		if ($maxLength === null) {
-			return new VarBitString($bits, null);
-		}
-		elseif ($maxLength <= 0) {
-			throw new \InvalidArgumentException('maxLength is non-positive');
-		}
-		elseif ($maxLength < strlen($bits)) {
-			trigger_error("Bit string truncated to the length of $maxLength", E_USER_WARNING);
-			return new VarBitString(substr($bits, 0, $maxLength), $maxLength);
-		}
-		else {
-			return new VarBitString($bits, $maxLength);
-		}
-	}
+        if ($maxLength === null) {
+            return new VarBitString($bits, null);
+        }
+        elseif ($maxLength <= 0) {
+            throw new \InvalidArgumentException('maxLength is non-positive');
+        }
+        elseif ($maxLength < strlen($bits)) {
+            trigger_error("Bit string truncated to the length of $maxLength", E_USER_WARNING);
+            return new VarBitString(substr($bits, 0, $maxLength), $maxLength);
+        }
+        else {
+            return new VarBitString($bits, $maxLength);
+        }
+    }
 
-	/**
-	 * @param string $bits
-	 * @param int|null $maxLength
-	 */
-	protected function __construct($bits, $maxLength)
-	{
-		parent::__construct($bits);
+    /**
+     * @param string $bits
+     * @param int|null $maxLength
+     */
+    protected function __construct($bits, $maxLength)
+    {
+        parent::__construct($bits);
 
-		if ($maxLength !== null && $maxLength < 0) { // NOTE: zero max. length permitted for substr() to calculate correctly
-			throw new \InvalidArgumentException('maxLength is negative');
-		}
-		$this->maxLength = $maxLength;
-	}
+        if ($maxLength !== null && $maxLength < 0) { // NOTE: zero max. length permitted for substr() to calculate correctly
+            throw new \InvalidArgumentException('maxLength is negative');
+        }
+        $this->maxLength = $maxLength;
+    }
 
-	public function equals($other)
-	{
-		$parRes = parent::equals($other);
-		if (!$parRes) {
-			return $parRes;
-		}
-		/** @var VarBitString $other */
-		return ($this->maxLength == $other->maxLength);
-	}
+    public function equals($other)
+    {
+        $parRes = parent::equals($other);
+        if (!$parRes) {
+            return $parRes;
+        }
+        /** @var VarBitString $other */
+        return ($this->maxLength == $other->maxLength);
+    }
 
-	/**
-	 * @return int|null maximal length this bit string might have carried, or <tt>null</tt> for unlimited length
-	 */
-	public function getMaxLength()
-	{
-		return $this->maxLength;
-	}
+    /**
+     * @return int|null maximal length this bit string might have carried, or <tt>null</tt> for unlimited length
+     */
+    public function getMaxLength()
+    {
+        return $this->maxLength;
+    }
 }

src/Ivory/Value/Decimal.php

Indentation +681 added lines, -681 removed lines

@@ -32,686 +32,686 @@
  */
 class Decimal implements IComparable
 {
-	/** Maximal number of decimal digits considered by PostgreSQL. */
-	const SCALE_LIMIT = 16383;
-	/**
-	 * Minimal number of significant digits for inexact calculations, like division or square root. It reflects the
-	 * behaviour of PostgreSQL.
-	 */
-	const MIN_SIG_DIGITS = 16;
-
-	/** @var string|null string of decimal digits, including the sign and decimal point; null for the not-a-number */
-	private $val;
-	/** @var int number of decimal digits in the fractional part, to the right of the decimal point (if any) */
-	private $scale;
-
-	/**
-	 * @param string|int|float|Decimal|object $decimalNumber the value of the decimal number;
-	 *                                                       leading zeros are ignored (even after the minus sign), as
-	 *                                                         well as leading and trailing whitespace;
-	 *                                                       if an object is passed, it gets cast to string (which works
-	 *                                                         for {@link \GMP} objects, besides others)
-	 * @param int|null $scale the requested scale (i.e., the number of decimal digits in the fractional part) of the
-	 *                          number;
-	 *                        must be non-negative, or null;
-	 *                        if smaller than the scale of the given number, the number gets mathematically rounded to
-	 *                          the requested scale;
-	 *                        if greater than the scale of the given number, the number gets padded to have such many
-	 *                          decimal places;
-	 *                        if not given, it is computed from the given number automatically
-	 * @return Decimal
-	 */
-	public static function fromNumber($decimalNumber, $scale = null)
-	{
-		if ($decimalNumber === null) {
-			throw new \InvalidArgumentException('decimalNumber');
-		}
-		if ($scale < 0) {
-			throw new \InvalidArgumentException('scale');
-		}
-		if ($decimalNumber instanceof Decimal) {
-			if ($scale === null || $scale == $decimalNumber->scale) {
-				return $decimalNumber;
-			}
-			else {
-				return $decimalNumber->round($scale);
-			}
-		}
-
-		if (is_int($decimalNumber)) {
-			$val = (string)$decimalNumber;
-		}
-		elseif (is_float($decimalNumber)) {
-			$val = (string)$decimalNumber;
-			$ePos = stripos($val, 'e');
-			if ($ePos > 0) {
-				$exp = (int)substr($val, $ePos + 1);
-				$decs = substr($val, 0, $ePos);
-				list($wp, $dp) = explode('.', $decs, 2);
-
-				if ($exp >= 0) {
-					$dpLen = strlen($dp);
-					if ($exp >= $dpLen) {
-						$val = $wp . $dp . str_repeat('0', $exp - $dpLen);
-					}
-					else {
-						$val = $wp . substr($dp, 0, $exp) . '.' . substr($dp, $exp);
-					}
-				}
-				else {
-					$mn = ($wp[0] == '-' ? 1 : 0);
-					$ord = strlen($wp) - $mn;
-					if (-$exp >= $ord) {
-						$prefix = ($mn ? '-' : '') . '0.' . str_repeat('0', -$exp - $ord);
-						if (($mn ? ($wp != '-0') : ($wp != '0'))) {
-							$prefix .= substr($wp, $mn);
-						}
-						$val = $prefix . $dp;
-					}
-					else {
-						$val = substr($wp, 0, $mn + $ord + $exp) . '.' . substr($wp, $mn + $ord + $exp) . $dp;
-					}
-				}
-			}
-		}
-		else {
-			if (!preg_match('~^\s*(-?)(?|(\.[0-9]+)|0*([0-9]+(?:\.[0-9]*)?))\s*$~', (string)$decimalNumber, $m)) {
-				throw new \InvalidArgumentException('decimalNumber');
-			}
-			$val = $m[1] . $m[2]; // cuts off unnecessary leading zeros
-		}
-
-		return new Decimal($val, $scale);
-	}
-
-	/**
-	 * Gets the not-a-number special value. Returns the same object every time.
-	 *
-	 * It only equals to the not-a-number, and is greater than any number value. The result of any operation is, again,
-	 * the not-a-number.
-	 *
-	 * @return Decimal the not-a-number value
-	 */
-	public static function NaN()
-	{
-		static $dec = null;
-		if ($dec === null) {
-			$dec = new Decimal(null);
-		}
-		return $dec;
-	}
-
-	/**
-	 * Gets the decimal object representing the number zero. Returns the same object every time.
-	 *
-	 * @return Decimal
-	 */
-	public static function zero()
-	{
-		static $dec = null;
-		if ($dec === null) {
-			$dec = new Decimal(0);
-		}
-		return $dec;
-	}
-
-	/**
-	 * NOTE: The constructor is kept private so that extra sanity checks are performed on user input, while trusting the
-	 *       results of the operations without these extra checks.
-	 *
-	 * @param string|null $val
-	 * @param int|null $scale
-	 */
-	private function __construct($val, $scale = null)
-	{
-		if ($val === null) {
-			$this->val = null;
-			$this->scale = null;
-			return;
-		}
-
-		$this->val = (string)$val;
-
-		$decPoint = strpos($this->val, '.');
-		if ($scale < 0) {
-			$this->scale = 0;
-			$minus = ($this->val[0] == '-' ? 1 : 0);
-			if ($decPoint !== false) {
-				$digits = substr($this->val, $minus, $decPoint - $minus);
-			}
-			else {
-				$digits = ($minus ? substr($this->val, $minus) : $this->val);
-			}
-			$len = strlen($digits);
-			$sigPos = $len + $scale;
-			if ($sigPos < 0) {
-				$this->val = '0';
-				return;
-			}
-			$inc = ($digits[$sigPos] >= 5);
-			if (!$inc && $sigPos == 0) {
-				$this->val = '0';
-				return;
-			}
-			for ($i = $sigPos; $i < $len; $i++) {
-				$digits[$i] = '0';
-			}
-			if ($inc) {
-				$augend = '1' . str_repeat('0', -$scale);
-				$digits = bcadd($digits, $augend, 0);
-			}
-			$this->val = ($minus ? '-' : '') . $digits;
-		}
-		elseif ($decPoint === false) {
-			if ($scale > 0) {
-				$this->val .= '.' . str_repeat('0', $scale);
-				$this->scale = $scale;
-			}
-			else {
-				$this->scale = 0;
-			}
-		}
-		else {
-			$len = strlen($this->val);
-			$this->scale = $len - $decPoint - 1;
-			$scale = min(self::SCALE_LIMIT, ($scale === null ? $this->scale : max(0, $scale)));
-			if ($this->scale < $scale) {
-				$this->val .= str_repeat('0', $scale - $this->scale);
-				$this->scale = $scale;
-			}
-			elseif ($this->scale > $scale) {
-				$newLen = $len - ($this->scale - $scale);
-				$inc = ($this->val[$newLen] >= 5);
-				if ($scale == 0) {
-					$newLen--;
-				}
-				$this->val = substr($this->val, 0, $newLen);
-				if ($inc) {
-					$mn = ($this->val[0] == '-' ? '-' : '');
-					$augend = $mn . ($scale == 0 ? '1' : '.' . str_repeat('0', $scale - 1) . '1');
-					$this->val = bcadd($this->val, $augend, $scale);
-				}
-				$this->scale = $scale;
-			}
-
-			if ($this->val[0] == '.') {
-				$this->val = '0' . $this->val;
-			}
-			elseif ($this->val[0] == '-' && $this->val[1] == '.') {
-				$this->val[0] = '0';
-				$this->val = '-' . $this->val;
-			}
-		}
-
-		// eliminate negative zero - PostgreSQL does not differentiate between zeros
-		if ($this->val[0] == '-' && strspn($this->val, '-0.') == strlen($this->val)) {
-			$this->val = substr($this->val, 1);
-		}
-	}
-
-
-	/**
-	 * @return int|null number of decimal digits in the fractional part, to the right of the decimal point (if any), or
-	 *                  <tt>null</tt> for the not-a-number
-	 */
-	public function getScale()
-	{
-		return $this->scale;
-	}
-
-	/**
-	 * Compare this number numerically with another number.
-	 *
-	 * Note that using the `==` operator checks that the two {@link Decimal} objects are of the same value and scale,
-	 * which might or might not be desired. Such a difference only arises in the trailing fractional zero digits,
-	 * though.
-	 *
-	 * @param string|int|float|Decimal|object $number number to compare this number with
-	 * @return bool whether this number numerically equals to <tt>$number</tt>
-	 */
-	public function equals($number)
-	{
-		if ($number === null) {
-			return null;
-		}
-		return ($this->compareTo($number) == 0);
-	}
-
-	/**
-	 * @param string|int|float|Decimal|object $number
-	 * @return bool <tt>true</tt> iff this number is numerically less than <tt>$number</tt>
-	 */
-	public function lessThan($number)
-	{
-		return ($this->compareTo($number) < 0);
-	}
-
-	/**
-	 * @param string|int|float|Decimal|object $number
-	 * @return bool <tt>true</tt> iff this number is numerically greater than <tt>$number</tt>
-	 */
-	public function greaterThan($number)
-	{
-		return ($this->compareTo($number) > 0);
-	}
-
-	/**
-	 * @param string|int|float|Decimal|object $number number to compare this number with
-	 * @return int -1, 0, or 1 if this number is numerically less than, equal to, or greater than <tt>$number</tt>
-	 */
-	public function compareTo($number)
-	{
-		$arg = self::fromNumber($number);
-		if ($this->isNaN()) {
-			if ($arg->isNaN()) {
-				return 0;
-			}
-			else {
-				return 1;
-			}
-		}
-		elseif ($arg->isNaN()) {
-			return -1;
-		}
-		else {
-			return bccomp($this->val, $arg->val, max($this->scale, $arg->scale));
-		}
-	}
-
-	/**
-	 * @return bool whether this is a not-a-number
-	 */
-	public function isNaN()
-	{
-		return ($this->val === null);
-	}
-
-	/**
-	 * @return bool whether this is zero
-	 */
-	public function isZero()
-	{
-		return ($this->equals(self::zero()));
-	}
-
-	/**
-	 * @return bool whether this is a positive number
-	 */
-	public function isPositive()
-	{
-		return (!$this->isNaN() && $this->compareTo(self::zero()) > 0);
-	}
-
-	/**
-	 * @return bool whether this is a negative number
-	 */
-	public function isNegative()
-	{
-		return (!$this->isNaN() && $this->val[0] == '-');
-	}
-
-	/**
-	 * @return bool whether this is an integer, i.e., a number without decimal part (or the decimal part equal to zero)
-	 */
-	public function isInteger()
-	{
-		if ($this->isNaN()) {
-			return false;
-		}
-		if (strpos($this->val, '.') === false) {
-			return true;
-		}
-		for ($i = strlen($this->val) - 1; ; $i--) {
-			switch ($this->val[$i]) {
-				case '.':
-					return true;
-				case '0':
-					break;
-				default:
-					return false;
-			}
-		}
-		return true;
-	}
-
-	/**
-	 * @param string|int|float|Decimal|object $augend
-	 * @return Decimal a new decimal number, representing the result of sum of this and the given number
-	 */
-	public function add($augend)
-	{
-		if ($this->isNaN()) {
-			return $this;
-		}
-		$arg = self::fromNumber($augend);
-		if ($arg->isNaN()) {
-			return $arg;
-		}
-		$scale = max($this->scale, $arg->scale);
-		return new Decimal(bcadd($this->val, $arg->val, $scale + 1), $scale);
-	}
-
-	/**
-	 * @param string|int|float|Decimal|object $subtrahend
-	 * @return Decimal a new decimal number, representing the result of subtraction of this and the given number
-	 */
-	public function subtract($subtrahend)
-	{
-		if ($this->isNaN()) {
-			return $this;
-		}
-		$arg = self::fromNumber($subtrahend);
-		if ($arg->isNaN()) {
-			return $arg;
-		}
-		$scale = max($this->scale, $arg->scale);
-		return new Decimal(bcsub($this->val, $arg->val, $scale + 1), $scale);
-	}
-
-	/**
-	 * @param string|int|float|Decimal|object $multiplicand
-	 * @return Decimal a new decimal number, representing the result of multiplication of this and the given number
-	 */
-	public function multiply($multiplicand)
-	{
-		if ($this->isNaN()) {
-			return $this;
-		}
-		$arg = self::fromNumber($multiplicand);
-		if ($arg->isNaN()) {
-			return $arg;
-		}
-		$scale = min($this->scale + $arg->scale, self::SCALE_LIMIT);
-		return new Decimal(bcmul($this->val, $arg->val, $scale + 1), $scale);
-	}
-
-	/**
-	 * @param string|int|float|Decimal|object $divisor
-	 * @return Decimal a new decimal number, representing the result of division of this number with the given number
-	 * @throws \RuntimeException if <tt>$divisor</tt> is zero
-	 */
-	public function divide($divisor)
-	{
-		if ($this->isNaN()) {
-			return $this;
-		}
-		$arg = self::fromNumber($divisor);
-		if ($arg->isNaN()) {
-			return $arg;
-		}
-		$scale = max($this->scale, $arg->scale, self::MIN_SIG_DIGITS);
-		return new Decimal(bcdiv($this->val, $arg->val, $scale + 1), $scale);
-	}
-
-	/**
-	 * @param string|int|float|Decimal|object $modulus
-	 * @return Decimal remainder of this number divided by <tt>$modulus</tt>
-	 * @throws \RuntimeException if <tt>$modulus</tt> is zero
-	 */
-	public function mod($modulus)
-	{
-		if ($this->isNaN()) {
-			return $this;
-		}
-		$arg = self::fromNumber($modulus);
-		if ($arg->isNaN()) {
-			return $arg;
-		}
-		if ($arg->isZero()) {
-			throw new \RuntimeException('Division by zero');
-		}
-
-		// NOTE: bcmod() only calculates integer modulus
-		$a = $this->abs();
-		$b = $arg->abs();
-		$m = $a->subtract($b->multiply($a->divide($b)->floor()));
-		if ($this->isNegative()) {
-			return $m->negate();
-		}
-		else {
-			return $m;
-		}
-	}
-
-	/**
-	 * @todo more precise calculation of fractional powers - now only double precision is used
-	 * @param string|int|float|Decimal|object $power
-	 * @return Decimal this number powered to <tt>$number</tt>
-	 * @throws \RuntimeException if this number is negative while <tt>$power</tt> is non-integer (that would lead to a
-	 *                             complex result)
-	 */
-	public function pow($power)
-	{
-		if ($this->isNaN()) {
-			return $this;
-		}
-		$arg = self::fromNumber($power);
-		if ($arg->isNaN()) {
-			return $arg;
-		}
-
-		$scale = max($this->scale, $arg->scale, self::MIN_SIG_DIGITS);
-
-		// NOTE: bcpow() only takes integer powers
-		if ($arg->isInteger()) {
-			return new Decimal(bcpow($this->val, $arg->val, $scale + 1), $scale);
-		}
-		else {
-			if ($this->isNegative()) {
-				throw new \RuntimeException('Negative number raised to a non-integer power yields a complex result');
-			}
-			return self::fromNumber(pow($this->toFloat(), $arg->toFloat()));
-		}
-	}
-
-	/**
-	 * @return Decimal the absolute value of this number
-	 */
-	public function abs()
-	{
-		if ($this->isNegative()) {
-			return $this->negate();
-		}
-		else {
-			return $this;
-		}
-	}
-
-	/**
-	 * @return Decimal a new decimal number, representing the negative value of this number
-	 */
-	public function negate()
-	{
-		if ($this->isNaN() || $this->isZero()) {
-			return $this;
-		}
-		elseif ($this->val[0] == '-') {
-			return new Decimal(substr($this->val, 1));
-		}
-		else {
-			return new Decimal('-' . $this->val);
-		}
-	}
-
-	/**
-	 * Computes the exact factorial of this number.
-	 * Only defined on numbers of scale zero, i.e., those without decimal part, and on the not-a-number.
-	 *
-	 * In conformance with PostgreSQL, the factorial of non-positive numbers is defined to be 1.
-	 *
-	 * @return Decimal the factorial of this number
-	 * @throws UndefinedOperationException if this number is neither a zero-scale number nor the not-a-number
-	 */
-	public function factorial()
-	{
-		if ($this->isNaN()) {
-			return $this;
-		}
-		if ($this->scale > 0) {
-			throw new UndefinedOperationException('Number with a decimal part');
-		}
-		if ($this->lessThan(2)) {
-			return new Decimal(1);
-		}
-
-		if (System::hasGMP()) {
-			return new Decimal(gmp_strval(gmp_fact($this->toGMP())));
-		}
-
-		// OPT: there are more efficient algorithms calculating the factorial; see, e.g., http://www.luschny.de/math/factorial/index.html
-		$result = new Decimal(2);
-		for ($i = new Decimal(3); $i->compareTo($this) <= 0; $i = $i->add(1)) {
-			$result = $result->multiply($i);
-		}
-		return $result;
-	}
-
-	/**
-	 * @param int $scale number of decimal places to round this number to; may be negative to round to higher orders
-	 * @return Decimal a new decimal number, representing this number rounded to <tt>$scale</tt> decimal places
-	 */
-	public function round($scale = 0)
-	{
-		return new Decimal($this->val, $scale);
-	}
-
-	/**
-	 * @return Decimal largest integer not greater than this number
-	 */
-	public function floor()
-	{
-		$decPoint = strpos($this->val, '.');
-		if ($decPoint === false) {
-			return $this;
-		}
-		if ($this->val[0] != '-') {
-			return new Decimal(substr($this->val, 0, $decPoint));
-		}
-		elseif ($this->isInteger()) {
-			return new Decimal($this->val, 0);
-		}
-		else {
-			// negative number with non-zero fractional part
-			return new Decimal(bcsub(substr($this->val, 0, $decPoint), 1, 0));
-		}
-	}
-
-	/**
-	 * @return Decimal smallest integer not less than this number
-	 */
-	public function ceil()
-	{
-		$decPoint = strpos($this->val, '.');
-		if ($decPoint === false) {
-			return $this;
-		}
-		if ($this->val[0] == '-') {
-			return new Decimal(substr($this->val, 0, $decPoint));
-		}
-		elseif ($this->isInteger()) {
-			return new Decimal($this->val, 0);
-		}
-		else {
-			// non-negative number with non-zero fractional part
-			return new Decimal(bcadd(substr($this->val, 0, $decPoint), 1, 0));
-		}
-	}
-
-	/**
-	 * @param string|int|float|Decimal|object $number
-	 * @return Decimal the greater of this number and <tt>$number</tt>, preferably this number if numerically equal
-	 */
-	public function max($number)
-	{
-		$arg = self::fromNumber($number);
-		if ($this->lessThan($arg)) {
-			return $arg;
-		}
-		else {
-			return $this;
-		}
-	}
-
-	/**
-	 * @param string|int|float|Decimal|object $number
-	 * @return Decimal the smaller of this number and <tt>$number</tt>, preferably this number if numerically equal
-	 */
-	public function min($number)
-	{
-		$arg = self::fromNumber($number);
-		if ($this->greaterThan($arg)) {
-			return $arg;
-		}
-		else {
-			return $this;
-		}
-	}
-
-	/**
-	 * @return Decimal a new decimal number, representing the square root of this number
-	 * @throws UndefinedOperationException if this is a negative number
-	 */
-	public function sqrt()
-	{
-		if ($this->isNaN()) {
-			return $this;
-		}
-		if ($this->isNegative()) {
-			throw new UndefinedOperationException('square root of negative number');
-		}
-		$scale = max($this->scale, self::MIN_SIG_DIGITS);
-		return new Decimal(bcsqrt($this->val, $scale + 1));
-	}
-
-
-	/**
-	 * @return int|null the value of this number cast explicitly to <tt>int</tt>;
-	 *                  for big numbers, this yields the maximal available integer value (i.e., <tt>PHP_INT_MAX</tt> or
-	 *                    <tt>PHP_INT_MIN</tt>);
+    /** Maximal number of decimal digits considered by PostgreSQL. */
+    const SCALE_LIMIT = 16383;
+    /**
+     * Minimal number of significant digits for inexact calculations, like division or square root. It reflects the
+     * behaviour of PostgreSQL.
+     */
+    const MIN_SIG_DIGITS = 16;
+
+    /** @var string|null string of decimal digits, including the sign and decimal point; null for the not-a-number */
+    private $val;
+    /** @var int number of decimal digits in the fractional part, to the right of the decimal point (if any) */
+    private $scale;
+
+    /**
+     * @param string|int|float|Decimal|object $decimalNumber the value of the decimal number;
+     *                                                       leading zeros are ignored (even after the minus sign), as
+     *                                                         well as leading and trailing whitespace;
+     *                                                       if an object is passed, it gets cast to string (which works
+     *                                                         for {@link \GMP} objects, besides others)
+     * @param int|null $scale the requested scale (i.e., the number of decimal digits in the fractional part) of the
+     *                          number;
+     *                        must be non-negative, or null;
+     *                        if smaller than the scale of the given number, the number gets mathematically rounded to
+     *                          the requested scale;
+     *                        if greater than the scale of the given number, the number gets padded to have such many
+     *                          decimal places;
+     *                        if not given, it is computed from the given number automatically
+     * @return Decimal
+     */
+    public static function fromNumber($decimalNumber, $scale = null)
+    {
+        if ($decimalNumber === null) {
+            throw new \InvalidArgumentException('decimalNumber');
+        }
+        if ($scale < 0) {
+            throw new \InvalidArgumentException('scale');
+        }
+        if ($decimalNumber instanceof Decimal) {
+            if ($scale === null || $scale == $decimalNumber->scale) {
+                return $decimalNumber;
+            }
+            else {
+                return $decimalNumber->round($scale);
+            }
+        }
+
+        if (is_int($decimalNumber)) {
+            $val = (string)$decimalNumber;
+        }
+        elseif (is_float($decimalNumber)) {
+            $val = (string)$decimalNumber;
+            $ePos = stripos($val, 'e');
+            if ($ePos > 0) {
+                $exp = (int)substr($val, $ePos + 1);
+                $decs = substr($val, 0, $ePos);
+                list($wp, $dp) = explode('.', $decs, 2);
+
+                if ($exp >= 0) {
+                    $dpLen = strlen($dp);
+                    if ($exp >= $dpLen) {
+                        $val = $wp . $dp . str_repeat('0', $exp - $dpLen);
+                    }
+                    else {
+                        $val = $wp . substr($dp, 0, $exp) . '.' . substr($dp, $exp);
+                    }
+                }
+                else {
+                    $mn = ($wp[0] == '-' ? 1 : 0);
+                    $ord = strlen($wp) - $mn;
+                    if (-$exp >= $ord) {
+                        $prefix = ($mn ? '-' : '') . '0.' . str_repeat('0', -$exp - $ord);
+                        if (($mn ? ($wp != '-0') : ($wp != '0'))) {
+                            $prefix .= substr($wp, $mn);
+                        }
+                        $val = $prefix . $dp;
+                    }
+                    else {
+                        $val = substr($wp, 0, $mn + $ord + $exp) . '.' . substr($wp, $mn + $ord + $exp) . $dp;
+                    }
+                }
+            }
+        }
+        else {
+            if (!preg_match('~^\s*(-?)(?|(\.[0-9]+)|0*([0-9]+(?:\.[0-9]*)?))\s*$~', (string)$decimalNumber, $m)) {
+                throw new \InvalidArgumentException('decimalNumber');
+            }
+            $val = $m[1] . $m[2]; // cuts off unnecessary leading zeros
+        }
+
+        return new Decimal($val, $scale);
+    }
+
+    /**
+     * Gets the not-a-number special value. Returns the same object every time.
+     *
+     * It only equals to the not-a-number, and is greater than any number value. The result of any operation is, again,
+     * the not-a-number.
+     *
+     * @return Decimal the not-a-number value
+     */
+    public static function NaN()
+    {
+        static $dec = null;
+        if ($dec === null) {
+            $dec = new Decimal(null);
+        }
+        return $dec;
+    }
+
+    /**
+     * Gets the decimal object representing the number zero. Returns the same object every time.
+     *
+     * @return Decimal
+     */
+    public static function zero()
+    {
+        static $dec = null;
+        if ($dec === null) {
+            $dec = new Decimal(0);
+        }
+        return $dec;
+    }
+
+    /**
+     * NOTE: The constructor is kept private so that extra sanity checks are performed on user input, while trusting the
+     *       results of the operations without these extra checks.
+     *
+     * @param string|null $val
+     * @param int|null $scale
+     */
+    private function __construct($val, $scale = null)
+    {
+        if ($val === null) {
+            $this->val = null;
+            $this->scale = null;
+            return;
+        }
+
+        $this->val = (string)$val;
+
+        $decPoint = strpos($this->val, '.');
+        if ($scale < 0) {
+            $this->scale = 0;
+            $minus = ($this->val[0] == '-' ? 1 : 0);
+            if ($decPoint !== false) {
+                $digits = substr($this->val, $minus, $decPoint - $minus);
+            }
+            else {
+                $digits = ($minus ? substr($this->val, $minus) : $this->val);
+            }
+            $len = strlen($digits);
+            $sigPos = $len + $scale;
+            if ($sigPos < 0) {
+                $this->val = '0';
+                return;
+            }
+            $inc = ($digits[$sigPos] >= 5);
+            if (!$inc && $sigPos == 0) {
+                $this->val = '0';
+                return;
+            }
+            for ($i = $sigPos; $i < $len; $i++) {
+                $digits[$i] = '0';
+            }
+            if ($inc) {
+                $augend = '1' . str_repeat('0', -$scale);
+                $digits = bcadd($digits, $augend, 0);
+            }
+            $this->val = ($minus ? '-' : '') . $digits;
+        }
+        elseif ($decPoint === false) {
+            if ($scale > 0) {
+                $this->val .= '.' . str_repeat('0', $scale);
+                $this->scale = $scale;
+            }
+            else {
+                $this->scale = 0;
+            }
+        }
+        else {
+            $len = strlen($this->val);
+            $this->scale = $len - $decPoint - 1;
+            $scale = min(self::SCALE_LIMIT, ($scale === null ? $this->scale : max(0, $scale)));
+            if ($this->scale < $scale) {
+                $this->val .= str_repeat('0', $scale - $this->scale);
+                $this->scale = $scale;
+            }
+            elseif ($this->scale > $scale) {
+                $newLen = $len - ($this->scale - $scale);
+                $inc = ($this->val[$newLen] >= 5);
+                if ($scale == 0) {
+                    $newLen--;
+                }
+                $this->val = substr($this->val, 0, $newLen);
+                if ($inc) {
+                    $mn = ($this->val[0] == '-' ? '-' : '');
+                    $augend = $mn . ($scale == 0 ? '1' : '.' . str_repeat('0', $scale - 1) . '1');
+                    $this->val = bcadd($this->val, $augend, $scale);
+                }
+                $this->scale = $scale;
+            }
+
+            if ($this->val[0] == '.') {
+                $this->val = '0' . $this->val;
+            }
+            elseif ($this->val[0] == '-' && $this->val[1] == '.') {
+                $this->val[0] = '0';
+                $this->val = '-' . $this->val;
+            }
+        }
+
+        // eliminate negative zero - PostgreSQL does not differentiate between zeros
+        if ($this->val[0] == '-' && strspn($this->val, '-0.') == strlen($this->val)) {
+            $this->val = substr($this->val, 1);
+        }
+    }
+
+
+    /**
+     * @return int|null number of decimal digits in the fractional part, to the right of the decimal point (if any), or
+     *                  <tt>null</tt> for the not-a-number
+     */
+    public function getScale()
+    {
+        return $this->scale;
+    }
+
+    /**
+     * Compare this number numerically with another number.
+     *
+     * Note that using the `==` operator checks that the two {@link Decimal} objects are of the same value and scale,
+     * which might or might not be desired. Such a difference only arises in the trailing fractional zero digits,
+     * though.
+     *
+     * @param string|int|float|Decimal|object $number number to compare this number with
+     * @return bool whether this number numerically equals to <tt>$number</tt>
+     */
+    public function equals($number)
+    {
+        if ($number === null) {
+            return null;
+        }
+        return ($this->compareTo($number) == 0);
+    }
+
+    /**
+     * @param string|int|float|Decimal|object $number
+     * @return bool <tt>true</tt> iff this number is numerically less than <tt>$number</tt>
+     */
+    public function lessThan($number)
+    {
+        return ($this->compareTo($number) < 0);
+    }
+
+    /**
+     * @param string|int|float|Decimal|object $number
+     * @return bool <tt>true</tt> iff this number is numerically greater than <tt>$number</tt>
+     */
+    public function greaterThan($number)
+    {
+        return ($this->compareTo($number) > 0);
+    }
+
+    /**
+     * @param string|int|float|Decimal|object $number number to compare this number with
+     * @return int -1, 0, or 1 if this number is numerically less than, equal to, or greater than <tt>$number</tt>
+     */
+    public function compareTo($number)
+    {
+        $arg = self::fromNumber($number);
+        if ($this->isNaN()) {
+            if ($arg->isNaN()) {
+                return 0;
+            }
+            else {
+                return 1;
+            }
+        }
+        elseif ($arg->isNaN()) {
+            return -1;
+        }
+        else {
+            return bccomp($this->val, $arg->val, max($this->scale, $arg->scale));
+        }
+    }
+
+    /**
+     * @return bool whether this is a not-a-number
+     */
+    public function isNaN()
+    {
+        return ($this->val === null);
+    }
+
+    /**
+     * @return bool whether this is zero
+     */
+    public function isZero()
+    {
+        return ($this->equals(self::zero()));
+    }
+
+    /**
+     * @return bool whether this is a positive number
+     */
+    public function isPositive()
+    {
+        return (!$this->isNaN() && $this->compareTo(self::zero()) > 0);
+    }
+
+    /**
+     * @return bool whether this is a negative number
+     */
+    public function isNegative()
+    {
+        return (!$this->isNaN() && $this->val[0] == '-');
+    }
+
+    /**
+     * @return bool whether this is an integer, i.e., a number without decimal part (or the decimal part equal to zero)
+     */
+    public function isInteger()
+    {
+        if ($this->isNaN()) {
+            return false;
+        }
+        if (strpos($this->val, '.') === false) {
+            return true;
+        }
+        for ($i = strlen($this->val) - 1; ; $i--) {
+            switch ($this->val[$i]) {
+                case '.':
+                    return true;
+                case '0':
+                    break;
+                default:
+                    return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * @param string|int|float|Decimal|object $augend
+     * @return Decimal a new decimal number, representing the result of sum of this and the given number
+     */
+    public function add($augend)
+    {
+        if ($this->isNaN()) {
+            return $this;
+        }
+        $arg = self::fromNumber($augend);
+        if ($arg->isNaN()) {
+            return $arg;
+        }
+        $scale = max($this->scale, $arg->scale);
+        return new Decimal(bcadd($this->val, $arg->val, $scale + 1), $scale);
+    }
+
+    /**
+     * @param string|int|float|Decimal|object $subtrahend
+     * @return Decimal a new decimal number, representing the result of subtraction of this and the given number
+     */
+    public function subtract($subtrahend)
+    {
+        if ($this->isNaN()) {
+            return $this;
+        }
+        $arg = self::fromNumber($subtrahend);
+        if ($arg->isNaN()) {
+            return $arg;
+        }
+        $scale = max($this->scale, $arg->scale);
+        return new Decimal(bcsub($this->val, $arg->val, $scale + 1), $scale);
+    }
+
+    /**
+     * @param string|int|float|Decimal|object $multiplicand
+     * @return Decimal a new decimal number, representing the result of multiplication of this and the given number
+     */
+    public function multiply($multiplicand)
+    {
+        if ($this->isNaN()) {
+            return $this;
+        }
+        $arg = self::fromNumber($multiplicand);
+        if ($arg->isNaN()) {
+            return $arg;
+        }
+        $scale = min($this->scale + $arg->scale, self::SCALE_LIMIT);
+        return new Decimal(bcmul($this->val, $arg->val, $scale + 1), $scale);
+    }
+
+    /**
+     * @param string|int|float|Decimal|object $divisor
+     * @return Decimal a new decimal number, representing the result of division of this number with the given number
+     * @throws \RuntimeException if <tt>$divisor</tt> is zero
+     */
+    public function divide($divisor)
+    {
+        if ($this->isNaN()) {
+            return $this;
+        }
+        $arg = self::fromNumber($divisor);
+        if ($arg->isNaN()) {
+            return $arg;
+        }
+        $scale = max($this->scale, $arg->scale, self::MIN_SIG_DIGITS);
+        return new Decimal(bcdiv($this->val, $arg->val, $scale + 1), $scale);
+    }
+
+    /**
+     * @param string|int|float|Decimal|object $modulus
+     * @return Decimal remainder of this number divided by <tt>$modulus</tt>
+     * @throws \RuntimeException if <tt>$modulus</tt> is zero
+     */
+    public function mod($modulus)
+    {
+        if ($this->isNaN()) {
+            return $this;
+        }
+        $arg = self::fromNumber($modulus);
+        if ($arg->isNaN()) {
+            return $arg;
+        }
+        if ($arg->isZero()) {
+            throw new \RuntimeException('Division by zero');
+        }
+
+        // NOTE: bcmod() only calculates integer modulus
+        $a = $this->abs();
+        $b = $arg->abs();
+        $m = $a->subtract($b->multiply($a->divide($b)->floor()));
+        if ($this->isNegative()) {
+            return $m->negate();
+        }
+        else {
+            return $m;
+        }
+    }
+
+    /**
+     * @todo more precise calculation of fractional powers - now only double precision is used
+     * @param string|int|float|Decimal|object $power
+     * @return Decimal this number powered to <tt>$number</tt>
+     * @throws \RuntimeException if this number is negative while <tt>$power</tt> is non-integer (that would lead to a
+     *                             complex result)
+     */
+    public function pow($power)
+    {
+        if ($this->isNaN()) {
+            return $this;
+        }
+        $arg = self::fromNumber($power);
+        if ($arg->isNaN()) {
+            return $arg;
+        }
+
+        $scale = max($this->scale, $arg->scale, self::MIN_SIG_DIGITS);
+
+        // NOTE: bcpow() only takes integer powers
+        if ($arg->isInteger()) {
+            return new Decimal(bcpow($this->val, $arg->val, $scale + 1), $scale);
+        }
+        else {
+            if ($this->isNegative()) {
+                throw new \RuntimeException('Negative number raised to a non-integer power yields a complex result');
+            }
+            return self::fromNumber(pow($this->toFloat(), $arg->toFloat()));
+        }
+    }
+
+    /**
+     * @return Decimal the absolute value of this number
+     */
+    public function abs()
+    {
+        if ($this->isNegative()) {
+            return $this->negate();
+        }
+        else {
+            return $this;
+        }
+    }
+
+    /**
+     * @return Decimal a new decimal number, representing the negative value of this number
+     */
+    public function negate()
+    {
+        if ($this->isNaN() || $this->isZero()) {
+            return $this;
+        }
+        elseif ($this->val[0] == '-') {
+            return new Decimal(substr($this->val, 1));
+        }
+        else {
+            return new Decimal('-' . $this->val);
+        }
+    }
+
+    /**
+     * Computes the exact factorial of this number.
+     * Only defined on numbers of scale zero, i.e., those without decimal part, and on the not-a-number.
+     *
+     * In conformance with PostgreSQL, the factorial of non-positive numbers is defined to be 1.
+     *
+     * @return Decimal the factorial of this number
+     * @throws UndefinedOperationException if this number is neither a zero-scale number nor the not-a-number
+     */
+    public function factorial()
+    {
+        if ($this->isNaN()) {
+            return $this;
+        }
+        if ($this->scale > 0) {
+            throw new UndefinedOperationException('Number with a decimal part');
+        }
+        if ($this->lessThan(2)) {
+            return new Decimal(1);
+        }
+
+        if (System::hasGMP()) {
+            return new Decimal(gmp_strval(gmp_fact($this->toGMP())));
+        }
+
+        // OPT: there are more efficient algorithms calculating the factorial; see, e.g., http://www.luschny.de/math/factorial/index.html
+        $result = new Decimal(2);
+        for ($i = new Decimal(3); $i->compareTo($this) <= 0; $i = $i->add(1)) {
+            $result = $result->multiply($i);
+        }
+        return $result;
+    }
+
+    /**
+     * @param int $scale number of decimal places to round this number to; may be negative to round to higher orders
+     * @return Decimal a new decimal number, representing this number rounded to <tt>$scale</tt> decimal places
+     */
+    public function round($scale = 0)
+    {
+        return new Decimal($this->val, $scale);
+    }
+
+    /**
+     * @return Decimal largest integer not greater than this number
+     */
+    public function floor()
+    {
+        $decPoint = strpos($this->val, '.');
+        if ($decPoint === false) {
+            return $this;
+        }
+        if ($this->val[0] != '-') {
+            return new Decimal(substr($this->val, 0, $decPoint));
+        }
+        elseif ($this->isInteger()) {
+            return new Decimal($this->val, 0);
+        }
+        else {
+            // negative number with non-zero fractional part
+            return new Decimal(bcsub(substr($this->val, 0, $decPoint), 1, 0));
+        }
+    }
+
+    /**
+     * @return Decimal smallest integer not less than this number
+     */
+    public function ceil()
+    {
+        $decPoint = strpos($this->val, '.');
+        if ($decPoint === false) {
+            return $this;
+        }
+        if ($this->val[0] == '-') {
+            return new Decimal(substr($this->val, 0, $decPoint));
+        }
+        elseif ($this->isInteger()) {
+            return new Decimal($this->val, 0);
+        }
+        else {
+            // non-negative number with non-zero fractional part
+            return new Decimal(bcadd(substr($this->val, 0, $decPoint), 1, 0));
+        }
+    }
+
+    /**
+     * @param string|int|float|Decimal|object $number
+     * @return Decimal the greater of this number and <tt>$number</tt>, preferably this number if numerically equal
+     */
+    public function max($number)
+    {
+        $arg = self::fromNumber($number);
+        if ($this->lessThan($arg)) {
+            return $arg;
+        }
+        else {
+            return $this;
+        }
+    }
+
+    /**
+     * @param string|int|float|Decimal|object $number
+     * @return Decimal the smaller of this number and <tt>$number</tt>, preferably this number if numerically equal
+     */
+    public function min($number)
+    {
+        $arg = self::fromNumber($number);
+        if ($this->greaterThan($arg)) {
+            return $arg;
+        }
+        else {
+            return $this;
+        }
+    }
+
+    /**
+     * @return Decimal a new decimal number, representing the square root of this number
+     * @throws UndefinedOperationException if this is a negative number
+     */
+    public function sqrt()
+    {
+        if ($this->isNaN()) {
+            return $this;
+        }
+        if ($this->isNegative()) {
+            throw new UndefinedOperationException('square root of negative number');
+        }
+        $scale = max($this->scale, self::MIN_SIG_DIGITS);
+        return new Decimal(bcsqrt($this->val, $scale + 1));
+    }
+
+
+    /**
+     * @return int|null the value of this number cast explicitly to <tt>int</tt>;
+     *                  for big numbers, this yields the maximal available integer value (i.e., <tt>PHP_INT_MAX</tt> or
+     *                    <tt>PHP_INT_MIN</tt>);
      *                  <tt>null</tt> is returned if this is the not-a-number
-	 */
-	public function toInt()
-	{
-		return ($this->val === null ? null : (int)$this->val);
-	}
-
-	/**
-	 * @return float the value of this number cast explicitly to <tt>float</tt>, or the float <tt>NAN</tt> value if this
-	 *                 is the not-a-number
-	 */
-	public function toFloat()
-	{
-		return ($this->val === null ? NAN : (float)$this->val);
-	}
-
-	/**
-	 * @return string the value of this number, or the special string <tt>'NaN'</tt> for the not-a-number value
-	 */
-	public function toString()
-	{
-		return ($this->val === null ? 'NaN' : $this->val);
-	}
-
-	/**
-	 * Converts the value to a {@link \GMP} object.
-	 *
-	 * Requires the `gmp` PHP extension.
-	 *
-	 * @return \GMP a {@link \GMP} object representing the same integer as this number
-	 * @throws UndefinedOperationException if this number is not an integer, i.e., has some non-zero fractional digits
-	 */
-	public function toGMP()
-	{
-		if (!$this->isInteger()) {
-			throw new UndefinedOperationException('toGMP() is only defined for integers');
-		}
-		$decPoint = strpos($this->val, '.');
-		$str = ($decPoint === false ? $this->val : substr($this->val, 0, $decPoint - 1));
-		return gmp_init($str);
-	}
-
-	public function __toString()
-	{
-		return $this->toString();
-	}
+     */
+    public function toInt()
+    {
+        return ($this->val === null ? null : (int)$this->val);
+    }
+
+    /**
+     * @return float the value of this number cast explicitly to <tt>float</tt>, or the float <tt>NAN</tt> value if this
+     *                 is the not-a-number
+     */
+    public function toFloat()
+    {
+        return ($this->val === null ? NAN : (float)$this->val);
+    }
+
+    /**
+     * @return string the value of this number, or the special string <tt>'NaN'</tt> for the not-a-number value
+     */
+    public function toString()
+    {
+        return ($this->val === null ? 'NaN' : $this->val);
+    }
+
+    /**
+     * Converts the value to a {@link \GMP} object.
+     *
+     * Requires the `gmp` PHP extension.
+     *
+     * @return \GMP a {@link \GMP} object representing the same integer as this number
+     * @throws UndefinedOperationException if this number is not an integer, i.e., has some non-zero fractional digits
+     */
+    public function toGMP()
+    {
+        if (!$this->isInteger()) {
+            throw new UndefinedOperationException('toGMP() is only defined for integers');
+        }
+        $decPoint = strpos($this->val, '.');
+        $str = ($decPoint === false ? $this->val : substr($this->val, 0, $decPoint - 1));
+        return gmp_init($str);
+    }
+
+    public function __toString()
+    {
+        return $this->toString();
+    }
 }

src/Ivory/Value/Money.php

Indentation +59 added lines, -59 removed lines

@@ -14,25 +14,25 @@ 
  */
 class Money
 {
-	private $amount;
-	private $unit;
+    private $amount;
+    private $unit;
 
 
-	/**
-	 * @param string $moneyStr the money quantity as a string;
-	 *                         the value must use <tt>$decimalSeparator</tt> as the decimal separator, but may use any
-	 *                           thousands separators;
-	 *                         the unit may occur either before or after the actual value, or not at all;
-	 *                         whitespace is ignored altogether except for the unit
-	 * @param string $decimalSeparator
-	 * @return Money the representation of the given quantity
-	 * @throws \InvalidArgumentException if the string does not conform to the recognized syntax (which is iff it does
-	 *                                     not contain any decimal digit)
-	 */
-	public static function fromString($moneyStr, $decimalSeparator)
-	{
-		$ds = preg_quote($decimalSeparator, '~');
-		$re = '~^ \s*
+    /**
+     * @param string $moneyStr the money quantity as a string;
+     *                         the value must use <tt>$decimalSeparator</tt> as the decimal separator, but may use any
+     *                           thousands separators;
+     *                         the unit may occur either before or after the actual value, or not at all;
+     *                         whitespace is ignored altogether except for the unit
+     * @param string $decimalSeparator
+     * @return Money the representation of the given quantity
+     * @throws \InvalidArgumentException if the string does not conform to the recognized syntax (which is iff it does
+     *                                     not contain any decimal digit)
+     */
+    public static function fromString($moneyStr, $decimalSeparator)
+    {
+        $ds = preg_quote($decimalSeparator, '~');
+        $re = '~^ \s*
                 (\D+?)?                             # optional unit before the amount
                 \s*
                 (\d(?:[^' . $ds . '\d]*\d+)*)       # the integer part of the amount
@@ -42,56 +42,56 @@ 
                 \s*
                 $~x';
 
-		if (!preg_match($re, $moneyStr, $m)) {
-			throw new \InvalidArgumentException('$moneyStr');
-		}
+        if (!preg_match($re, $moneyStr, $m)) {
+            throw new \InvalidArgumentException('$moneyStr');
+        }
 
-		$amount = preg_replace('~\D+~', '', $m[2]);
-		if (isset($m[3]) && $m[3] !== '') {
-			$amount .= '.' . preg_replace('~\D+~', '', $m[3]);
-		}
+        $amount = preg_replace('~\D+~', '', $m[2]);
+        if (isset($m[3]) && $m[3] !== '') {
+            $amount .= '.' . preg_replace('~\D+~', '', $m[3]);
+        }
 
-		$decimal = Decimal::fromNumber($amount);
-		$unit = ($m[1] !== '' ? $m[1] : (isset($m[4]) && $m[4] !== '' ? $m[4] : null));
+        $decimal = Decimal::fromNumber($amount);
+        $unit = ($m[1] !== '' ? $m[1] : (isset($m[4]) && $m[4] !== '' ? $m[4] : null));
 
-		return new Money($decimal, $unit);
-	}
+        return new Money($decimal, $unit);
+    }
 
-	public static function fromNumber($amount, $unit = null)
-	{
-		$decimal = Decimal::fromNumber($amount);
-		if ($decimal->isNaN()) {
-			throw new \InvalidArgumentException('$amount cannot be NaN');
-		}
+    public static function fromNumber($amount, $unit = null)
+    {
+        $decimal = Decimal::fromNumber($amount);
+        if ($decimal->isNaN()) {
+            throw new \InvalidArgumentException('$amount cannot be NaN');
+        }
 
-		return new Money($decimal, $unit);
-	}
+        return new Money($decimal, $unit);
+    }
 
 
-	private function __construct($amount, $unit)
-	{
-		$this->amount = $amount;
-		$this->unit = $unit;
-	}
+    private function __construct($amount, $unit)
+    {
+        $this->amount = $amount;
+        $this->unit = $unit;
+    }
 
-	/**
-	 * @return Decimal
-	 */
-	public function getAmount()
-	{
-		return $this->amount;
-	}
+    /**
+     * @return Decimal
+     */
+    public function getAmount()
+    {
+        return $this->amount;
+    }
 
-	/**
-	 * @return string|null the money unit (e.g., <tt>$</tt>), or <tt>null</tt> if no unit is specified for this amount
-	 */
-	public function getUnit()
-	{
-		return $this->unit;
-	}
+    /**
+     * @return string|null the money unit (e.g., <tt>$</tt>), or <tt>null</tt> if no unit is specified for this amount
+     */
+    public function getUnit()
+    {
+        return $this->unit;
+    }
 
-	public function __toString()
-	{
-		return "{$this->amount} " . ($this->unit === null ? '(no unit)' : $this->unit);
-	}
+    public function __toString()
+    {
+        return "{$this->amount} " . ($this->unit === null ? '(no unit)' : $this->unit);
+    }
 }