SKien\PNServer\Utils\Math

Complexity

Total Complexity

16

Size/Duplication

Total Lines	92
Duplicated Lines	0 %

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	bitwiseXor()	0	3	1
A	modDiv()	0	3	1
A	add()	0	3	1
A	sub()	0	3	1
A	modSub()	0	3	1
A	bitwiseAnd()	0	3	1
A	equals()	0	3	1
A	modMul()	0	3	1
A	mul()	0	3	1
A	mod()	0	3	1
A	toString()	0	3	1
A	pow()	0	3	1
A	cmp()	0	3	1
A	inverseMod()	0	3	1
A	baseConvert()	0	3	1
A	rightShift()	0	4	1

<?php
declare(strict_types=1);

namespace SKien\PNServer\Utils;

/*
 * extracted required classes and functions from package
 *		spomky-labs/jose
 *		https://github.com/Spomky-Labs/Jose 
 *
 * @package PNServer
 * @version 1.0.0
 * @copyright MIT License - see the copyright below and LICENSE file for details
 */

/*
 * *********************************************************************
 * Copyright (c) 2014-2016 Spomky-Labs
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES
 * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 * ***********************************************************************
 */

/**
 * @internal
 */
class Math
{
    public static function cmp(\GMP $first, \GMP $other) : int
    {
        return \gmp_cmp($first, $other);
    }

    public static function equals(\GMP $first, \GMP $other) : bool
    {
        return 0 === \gmp_cmp($first, $other);
    }

    public static function mod(\GMP $number, \GMP $modulus) : \GMP
    {
        return \gmp_mod($number, $modulus);

The expression return gmp_mod($number, $modulus) could return the type resource which is incompatible with the type-hinted return GMP. Consider adding an additional type-check to rule them out.

    }

    public static function add(\GMP $augend, \GMP $addend) : \GMP
    {
        return \gmp_add($augend, $addend);

The expression return gmp_add($augend, $addend) could return the type resource which is incompatible with the type-hinted return GMP. Consider adding an additional type-check to rule them out.

    }

    public static function sub(\GMP $minuend, \GMP $subtrahend) : \GMP
    {
        return \gmp_sub($minuend, $subtrahend);

The expression return gmp_sub($minuend, $subtrahend) could return the type resource which is incompatible with the type-hinted return GMP. Consider adding an additional type-check to rule them out.

    }

    public static function mul(\GMP $multiplier, \GMP $multiplicand) : \GMP
    {
        return \gmp_mul($multiplier, $multiplicand);

The expression return gmp_mul($multiplier, $multiplicand) could return the type resource which is incompatible with the type-hinted return GMP. Consider adding an additional type-check to rule them out.

    }

    public static function pow(\GMP $base, int $exponent) : \GMP 
    {
        return \gmp_pow($base, $exponent);

The expression return gmp_pow($base, $exponent) could return the type resource which is incompatible with the type-hinted return GMP. Consider adding an additional type-check to rule them out.

    }

    public static function bitwiseAnd(\GMP $first, \GMP $other) : \GMP
    {
        return \gmp_and($first, $other);

The expression return gmp_and($first, $other) could return the type resource which is incompatible with the type-hinted return GMP. Consider adding an additional type-check to rule them out.

    }

    public static function bitwiseXor(\GMP $first, \GMP $other) : \GMP
    {
        return \gmp_xor($first, $other);

The expression return gmp_xor($first, $other) could return the type resource which is incompatible with the type-hinted return GMP. Consider adding an additional type-check to rule them out.

    }

    public static function toString(\GMP  $value) : string
    {
        return \gmp_strval($value);
    }

    /**
     * @param \GMP $a
     * @param \GMP $m
     * @return \GMP|bool
     */
    public static function inverseMod(\GMP $a, \GMP $m)
    {
        return \gmp_invert($a, $m);

The expression return gmp_invert($a, $m) also could return the type resource which is incompatible with the documented return type GMP|boolean.

    }

    /**
     * @param int|string $number
     * @param int $from
     * @param int $to
     * @return string
     */
    public static function baseConvert($number, int $from, int $to) : string
    {
        return \gmp_strval(\gmp_init($number, $from), $to);
    }

    public static function rightShift(\GMP $number, int $positions) : \GMP 
    {
        // when using \gmp_div, phpStan says: Method SKien\PNServer\Utils\Math::rightShift() should return GMP but returns resource. ?
        return \gmp_div_q($number, \gmp_pow(\gmp_init(2, 10), $positions));

The expression return gmp_div_q($number, gmp_pow(gmp_init(2, 10), $positions)) could return the type resource which is incompatible with the type-hinted return GMP. Consider adding an additional type-check to rule them out.

    }
    
    public static function modSub(\GMP $minuend, \GMP $subtrahend, \GMP $modulus) : \GMP
   	{
   		return self::mod(self::sub($minuend, $subtrahend), $modulus);
   	}
    
   	public static function modMul(\GMP $multiplier, \GMP $muliplicand, \GMP $modulus) : \GMP
   	{
   		return self::mod(self::mul($multiplier, $muliplicand), $modulus);
   	}
    
   	public static function modDiv(\GMP $dividend, \GMP $divisor, \GMP $modulus) : \GMP
   	{
   		return self::mul($dividend, self::inverseMod($divisor, $modulus));
   	}
}