/** * This method causes the iterator to advance to the next object. * * @access public * @final * @return IBool\Type whether there are more objects */ public final function next() : IBool\Type { $this->i = IInt32\Module::increment($this->i); return IBool\Type::box($this->valid()); }
/** * This constructor creates a new runtime exception. * * @access public * @param string $message the error message * @param array $values the value to be formatted * @param IInt32\Type $code the exception code */ public function __construct($message = '', array $values = null, IInt32\Type $code = null) { parent::__construct(empty($values) ? (string) $message : strtr((string) $message, $values), IInt32\Module::nvl($code)->unbox()); }
/** * This method provides the data for testing the "foldRight" method. * * @return array */ public function data_foldRight() { $predicate = function (IInt32\Type $c, IInt32\Type $x) : IInt32\Type { return IInt32\Module::add($c, $x); }; $data = array(array(array(array(), $predicate), array(0)), array(array(array(1), $predicate), array(1)), array(array(array(1, 2), $predicate), array(3)), array(array(array(1, 2, 3), $predicate), array(6)), array(array(array(1, 2, 3, 4), $predicate), array(10))); return $data; }
/** * This method returns the numerically lowest value. * * @access public * @static * @param IInt32\Type $x the left operand * @param IInt32\Type $y the right operand * @return IInt32\Type the minimum value */ public static function min(IInt32\Type $x, IInt32\Type $y) : IInt32\Type { return IInt32\Module::compare($x, $y)->unbox() <= 0 ? $x : $y; }
/** * This method returns the collection as a linked list. * * @access public * @static * @param IString\Type $xs the operand * @return ILinkedList\Type the collection as a linked list */ public static function toLinkedList(IString\Type $xs) : ILinkedList\Type { $length = $xs->length(); $zs = ILinkedList\Type::nil(); for ($i = IInt32\Module::decrement($length); IInt32\Module::ge($i, IInt32\Type::zero())->unbox(); $i = IInt32\Module::decrement($i)) { $zs = ILinkedList\Type::cons($xs->item($i), $zs); } return $zs; }
/** * This method tests the "isOdd" method. * * @dataProvider data_isOdd */ public function test_isOdd(array $provided, array $expected) { $p0 = IInt32\Module::isOdd(IInt32\Type::box($provided[0])); $e0 = $expected[0]; $this->assertInstanceOf('\\Saber\\Data\\IBool\\Type', $p0); $this->assertSame($e0, $p0->unbox()); }
/** * This method returns the length of this linked list. * * @access public * @final * @return IInt32\Type the length of this linked list */ public final function length() : IInt32\Type { $c = IInt32\Type::zero(); for ($zs = $this; !$zs->__isEmpty(); $zs = $zs->tail()) { $c = IInt32\Module::increment($c); } return $c; }
/** * This method returns a random number with the range of x and y. * * @access public * @static * @param IInteger\Type $x the min operand * @param IInt32\Type $y the max operand * @return IInteger\Type the result */ public static function random(IInteger\Type $x = null, IInt32\Type $y = null) : IInteger\Type { return IInteger\Type::box(gmp_strval(gmp_random(IInt32\Module::nvl($y, IInt32\Type::one())->unbox()))); }
/** * This method evaluates whether the left operand is identical to the right operand. * * @access public * @static * @param IHashMap\Type $xs the left operand * @param Core\Type $ys the right operand * @return IBool\Type whether the left operand is identical * to the right operand */ public static function id(IHashMap\Type $xs, Core\Type $ys) : IBool\Type { // === if ($ys !== null && $xs->__typeOf() === $ys->__typeOf()) { if (IInt32\Module::eq($xs->size(), $ys->size())) { return IBool\Type::box((string) serialize($xs) == (string) serialize($ys)); } } return IBool\Type::false(); }
/** * This method returns a value as a boxed object. A value is typically a PHP typed * primitive or object. It is considered type-safe. * * @access public * @static * @param mixed $value the value(s) to be boxed * @return IRatio\Type the boxed object */ public static function make($value) : IRatio\Type { $values = is_array($value) ? $value : func_get_args(); $values = array_map(function ($value) { return $value instanceof IInt32\Type ? $value : IInt32\Type::make($value); }, $values); $denominator = $values[1]; $signum = IInt32\Module::signum($denominator)->unbox(); if ($signum == 0) { throw new Throwable\InvalidArgument\Exception('Unable to create ratio. Denominator must not be zero.'); } $numerator = $values[0]; if (IInt32\Module::signum($numerator)->unbox() == 0) { return IRatio\Type::zero(); } if ($signum < 0) { $numerator = IInt32\Module::negate($numerator); $denominator = IInt32\Module::negate($denominator); } $gcd = IInt32\Module::gcd($numerator, $denominator); if (!IInt32\Module::eq($gcd, IInt32\Type::one())->unbox()) { $numerator = IInt32\Module::divide($numerator, $gcd); $denominator = IInt32\Module::divide($denominator, $gcd); } return new IRatio\Type($numerator, $denominator); }
/** * This method compares the operands for order. * * @access public * @static * @param ITuple\Type $xs the left operand * @param ITuple\Type $ys the right operand * @return ITrit\Type the order as to whether the left * operand is less than, equals to, * or greater than the right operand */ public static function compare(ITuple\Type $xs, ITuple\Type $ys) : ITrit\Type { $xsl = $xs->length(); $ysl = $ys->length(); $length = IInt32\Module::min($xsl, $ysl); for ($i = IInt32\Type::zero(); IInt32\Module::lt($i, $length)->unbox(); $i = IInt32\Module::increment($i)) { $r = $xs->item($i)->compare($ys->item($i)); if ($r->unbox() != 0) { return $r; } } return ITrit\Type::box($xsl->unbox() <=> $ysl->unbox()); }
/** * This method returns the result of rounding this object's value. * * @access public * @static * @param IFloat\Type $x the operand * @param IInt32\Type $precision the precision to use when rounding * @return IFloat\Type the result */ public static function round(IFloat\Type $x, IInt32\Type $precision = null) : IFloat\Type { return IFloat\Type::box(round($x->unbox(), IInt32\Module::nvl($precision)->unbox())); }
/** * This method returns whether the operand is a negative number. * * @access public * @static * @param IRatio\Type $x the object to be evaluated * @return IBool\Type whether the operand is a negative * number */ public static function isNegative(IRatio\Type $x) : IBool\Type { $a = IInt32\Module::isNegative($x->numerator())->unbox(); $b = IInt32\Module::isNegative($x->denominator())->unbox(); return IBool\Type::box(($a || $b) && $a != $b); }
/** * This method returns each item in this collection until the predicate fails. * * @access public * @static * @param ILinkedList\Type $xs the left operand * @param callable $predicate the predicate function to be used * @return ILinkedList\Type the list */ public static function takeWhile(ILinkedList\Type $xs, callable $predicate) : ILinkedList\Type { $start = ILinkedList\Type::nil(); $tail = null; $taking = true; $i = IInt32\Type::zero(); for ($zs = $xs; !$zs->__isEmpty() && $taking; $zs = $zs->tail()) { $z = $zs->head(); if ($predicate($z, $i)->unbox()) { $ys = ILinkedList\Type::cons($z); if ($tail !== null) { $tail->tail = $ys; } else { $start = $ys; } $tail = $ys; } else { $taking = false; } $i = IInt32\Module::increment($i); } return $start; }