Zend_Locale_Math_PhpMath Class Reference

Inheritance diagram for Zend_Locale_Math_PhpMath:

Static Public Member Functions
static	disable ()
static	Add ($op1, $op2, $scale=null)
static	Sub ($op1, $op2, $scale=null)
static	Pow ($op1, $op2, $scale=null)
static	Mul ($op1, $op2, $scale=null)
static	Div ($op1, $op2, $scale=null)
static	Sqrt ($op1, $scale=null)
static	Mod ($op1, $op2)
static	Comp ($op1, $op2, $scale=null)
static	Scale ($scale)
Static Public Member Functions inherited from Zend_Locale_Math
static	isBcmathDisabled ()
static	round ($op1, $precision=0)
static	floatalize ($value)
static	normalize ($value)
static	localize ($value)
static	exponent ($value, $scale=null)
static	Add ($op1, $op2, $scale=null)
static	Sub ($op1, $op2, $scale=null)
static	Pow ($op1, $op2, $scale=null)
static	Mul ($op1, $op2, $scale=null)
static	Div ($op1, $op2, $scale=null)
static	Sqrt ($op1, $scale=null)
static	Mod ($op1, $op2)
static	Comp ($op1, $op2, $scale=null)

Static Public Attributes
static	$defaultScale
static	$defaultPrecision
Static Public Attributes inherited from Zend_Locale_Math
static	$_bcmathDisabled = false
static	$add = array('Zend_Locale_Math', 'Add')
static	$sub = array('Zend_Locale_Math', 'Sub')
static	$pow = array('Zend_Locale_Math', 'Pow')
static	$mul = array('Zend_Locale_Math', 'Mul')
static	$div = array('Zend_Locale_Math', 'Div')
static	$comp = array('Zend_Locale_Math', 'Comp')
static	$sqrt = array('Zend_Locale_Math', 'Sqrt')
static	$mod = array('Zend_Locale_Math', 'Mod')
static	$scale = 'bcscale'

Detailed Description

Definition at line 34 of file PhpMath.php.

Member Function Documentation

Add()

static Add (   $op1,   $op2,   $scale = null  )

static

Definition at line 57 of file PhpMath.php.

    {
        if ($scale === null) {
            $scale     = Zend_Locale_Math_PhpMath::$defaultScale;
            $precision = Zend_Locale_Math_PhpMath::$defaultPrecision;
        } else {
            $precision = pow(10, -$scale);
        }

        if (empty($op1)) {
            $op1 = 0;
        }
        $op1 = self::normalize($op1);
        $op2 = self::normalize($op2);
        $result = $op1 + $op2;
        if (is_infinite($result)  or  (abs($result - $op2 - $op1) > $precision)) {
            #require_once 'Zend/Locale/Math/Exception.php';
            throw new Zend_Locale_Math_Exception("addition overflow: $op1 + $op2 != $result", $op1, $op2, $result);
        }

        return self::round(self::normalize($result), $scale);
    }

Comp()

static Comp (   $op1,   $op2,   $scale = null  )

static

Definition at line 209 of file PhpMath.php.

    {
        if ($scale === null) {
            $scale     = Zend_Locale_Math_PhpMath::$defaultScale;
        }

        if (empty($op1)) {
            $op1 = 0;
        }
        $op1 = self::normalize($op1);
        $op2 = self::normalize($op2);
        if ($scale <> 0) {
            $op1 = self::round($op1, $scale);
            $op2 = self::round($op2, $scale);
        } else {
            $op1 = ($op1 > 0) ? floor($op1) : ceil($op1);
            $op2 = ($op2 > 0) ? floor($op2) : ceil($op2);
        }
        if ($op1 > $op2) {
            return 1;
        } else if ($op1 < $op2) {
            return -1;
        }
        return 0;
    }

disable()

static disable ( )

static

Definition at line 36 of file PhpMath.php.

    {
        self::$_bcmathDisabled = true;
        self::$add   = array('Zend_Locale_Math_PhpMath', 'Add');
        self::$sub   = array('Zend_Locale_Math_PhpMath', 'Sub');
        self::$pow   = array('Zend_Locale_Math_PhpMath', 'Pow');
        self::$mul   = array('Zend_Locale_Math_PhpMath', 'Mul');
        self::$div   = array('Zend_Locale_Math_PhpMath', 'Div');
        self::$comp  = array('Zend_Locale_Math_PhpMath', 'Comp');
        self::$sqrt  = array('Zend_Locale_Math_PhpMath', 'Sqrt');
        self::$mod   = array('Zend_Locale_Math_PhpMath', 'Mod');
        self::$scale = array('Zend_Locale_Math_PhpMath', 'Scale');

        self::$defaultScale     = 0;
        self::$defaultPrecision = 1;
    }

Div()

static Div (   $op1,   $op2,   $scale = null  )

static

Definition at line 145 of file PhpMath.php.

    {
        if ($scale === null) {
            $scale = Zend_Locale_Math_PhpMath::$defaultScale;
        }

        if (empty($op2)) {
            #require_once 'Zend/Locale/Math/Exception.php';
            throw new Zend_Locale_Math_Exception("can not divide by zero", $op1, $op2, null);
        }
        if (empty($op1)) {
            $op1 = 0;
        }
        $op1 = self::normalize($op1);
        $op2 = self::normalize($op2);
        $result = $op1 / $op2;
        if (is_infinite($result)  or  is_nan($result)) {
            #require_once 'Zend/Locale/Math/Exception.php';
            throw new Zend_Locale_Math_Exception("division overflow: $op1 / $op2 != $result", $op1, $op2, $result);
        }

        return self::round(self::normalize($result), $scale);
    }

Mod()

static Mod (   $op1,   $op2  )

static

Definition at line 187 of file PhpMath.php.

    {
        if (empty($op1)) {
            $op1 = 0;
        }
        if (empty($op2)) {
            return NULL;
        }
        $op1 = self::normalize($op1);
        $op2 = self::normalize($op2);
        if ((int)$op2 == 0) {
            return NULL;
        }
        $result = $op1 % $op2;
        if (is_nan($result)  or  (($op1 - $result) % $op2 != 0)) {
            #require_once 'Zend/Locale/Math/Exception.php';
            throw new Zend_Locale_Math_Exception("modulus calculation error: $op1 % $op2 != $result", $op1, $op2, $result);
        }

        return self::normalize($result);
    }

Mul()

static Mul (   $op1,   $op2,   $scale = null  )

static

Definition at line 125 of file PhpMath.php.

    {
        if ($scale === null) {
            $scale = Zend_Locale_Math_PhpMath::$defaultScale;
        }

        if (empty($op1)) {
            $op1 = 0;
        }
        $op1 = self::normalize($op1);
        $op2 = self::normalize($op2);
        $result = $op1 * $op2;
        if (is_infinite($result)  or  is_nan($result)) {
            #require_once 'Zend/Locale/Math/Exception.php';
            throw new Zend_Locale_Math_Exception("multiplication overflow: $op1 * $op2 != $result", $op1, $op2, $result);
        }

        return self::round(self::normalize($result), $scale);
    }

Pow()

static Pow (   $op1,   $op2,   $scale = null  )

static

Definition at line 103 of file PhpMath.php.

    {
        if ($scale === null) {
            $scale = Zend_Locale_Math_PhpMath::$defaultScale;
        }

        $op1 = self::normalize($op1);
        $op2 = self::normalize($op2);

        // BCMath extension doesn't use decimal part of the power
        // Provide the same behavior
        $op2 = ($op2 > 0) ? floor($op2) : ceil($op2);

        $result = pow($op1, $op2);
        if (is_infinite($result)  or  is_nan($result)) {
            #require_once 'Zend/Locale/Math/Exception.php';
            throw new Zend_Locale_Math_Exception("power overflow: $op1 ^ $op2", $op1, $op2, $result);
        }

        return self::round(self::normalize($result), $scale);
    }

Scale()

static Scale (   $scale )

static

Definition at line 235 of file PhpMath.php.

    {
        if ($scale > 9) {
            #require_once 'Zend/Locale/Math/Exception.php';
            throw new Zend_Locale_Math_Exception("can not scale to precision $scale", $scale, null, null);
        }
        self::$defaultScale     = $scale;
        self::$defaultPrecision = pow(10, -$scale);
        return true;
    }

Sqrt()

static Sqrt (   $op1,   $scale = null  )

static

Definition at line 169 of file PhpMath.php.

    {
        if ($scale === null) {
            $scale = Zend_Locale_Math_PhpMath::$defaultScale;
        }

        if (empty($op1)) {
            $op1 = 0;
        }
        $op1 = self::normalize($op1);
        $result = sqrt($op1);
        if (is_nan($result)) {
            return NULL;
        }

        return self::round(self::normalize($result), $scale);
    }

Sub()

static Sub (   $op1,   $op2,   $scale = null  )

static

Definition at line 80 of file PhpMath.php.

    {
        if ($scale === null) {
            $scale     = Zend_Locale_Math_PhpMath::$defaultScale;
            $precision = Zend_Locale_Math_PhpMath::$defaultPrecision;
        } else {
            $precision = pow(10, -$scale);
        }

        if (empty($op1)) {
            $op1 = 0;
        }
        $op1  = self::normalize($op1);
        $op2  = self::normalize($op2);
        $result = $op1 - $op2;
        if (is_infinite($result)  or  (abs($result + $op2 - $op1) > $precision)) {
            #require_once 'Zend/Locale/Math/Exception.php';
            throw new Zend_Locale_Math_Exception("subtraction overflow: $op1 - $op2 != $result", $op1, $op2, $result);
        }

        return self::round(self::normalize($result), $scale);
    }

Field Documentation

$defaultPrecision

$defaultPrecision

static

Definition at line 54 of file PhpMath.php.

$defaultScale

$defaultScale

static

Definition at line 53 of file PhpMath.php.

---

The documentation for this class was generated from the following file:

• vendor/magento/zendframework1/library/Zend/Locale/Math/PhpMath.php