Shell Bypass 403 GE-C666C

Ghost Exploiter Team Official

Directory >> /var/www/html/back/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/MathTrig/

File / Folder	Size	Action
.	-
Trig	--	ren
Absolute.php	0.98KB	edt ren
Angle.php	1.767KB	edt ren
Arabic.php	2.907KB	edt ren
Base.php	2.236KB	edt ren
Ceiling.php	5.958KB	edt ren
Combinations.php	3.543KB	edt ren
Exp.php	0.972KB	edt ren
Factorial.php	3.728KB	edt ren
Floor.php	6.539KB	edt ren
Gcd.php	1.98KB	edt ren
Helpers.php	3.131KB	edt ren
IntClass.php	1.063KB	edt ren
Lcm.php	3.58KB	edt ren
Logarithms.php	3.168KB	edt ren
MatrixFunctions.php	5.181KB	edt ren
Operations.php	4.879KB	edt ren
Random.php	3.254KB	edt ren
Roman.php	26.077KB	edt ren
Round.php	7.814KB	edt ren
SeriesSum.php	1.573KB	edt ren
Sign.php	1.099KB	edt ren
Sqrt.php	1.839KB	edt ren
Subtotal.php	4.636KB	edt ren
Sum.php	3.389KB	edt ren
SumSquares.php	3.908KB	edt ren
Trunc.php	1.206KB	edt ren

<?php

namespace PhpOffice\PhpSpreadsheet\Calculation\MathTrig;

use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
use PhpOffice\PhpSpreadsheet\Calculation\Exception;
use PhpOffice\PhpSpreadsheet\Calculation\Functions;
use PhpOffice\PhpSpreadsheet\Calculation\Information\ExcelError;

class Operations
{
    use ArrayEnabled;

/**
     * MOD.
     *
     * @param mixed $dividend Dividend
     *                      Or can be an array of values
     * @param mixed $divisor Divisor
     *                      Or can be an array of values
     *
     * @return array|float|int|string Remainder, or a string containing an error
     *         If an array of numbers is passed as an argument, then the returned result will also be an array
     *            with the same dimensions
     */
    public static function mod($dividend, $divisor)
    {
        if (is_array($dividend) || is_array($divisor)) {
            return self::evaluateArrayArguments([self::class, __FUNCTION__], $dividend, $divisor);
        }

try {
            $dividend = Helpers::validateNumericNullBool($dividend);
            $divisor = Helpers::validateNumericNullBool($divisor);
            Helpers::validateNotZero($divisor);
        } catch (Exception $e) {
            return $e->getMessage();
        }

if (($dividend < 0.0) && ($divisor > 0.0)) {
            return $divisor - fmod(abs($dividend), $divisor);
        }
        if (($dividend > 0.0) && ($divisor < 0.0)) {
            return $divisor + fmod($dividend, abs($divisor));
        }

return fmod($dividend, $divisor);
    }

/**
     * POWER.
     *
     * Computes x raised to the power y.
     *
     * @param array|float|int $x
     *                      Or can be an array of values
     * @param array|float|int $y
     *                      Or can be an array of values
     *
     * @return array|float|int|string The result, or a string containing an error
     *         If an array of numbers is passed as an argument, then the returned result will also be an array
     *            with the same dimensions
     */
    public static function power($x, $y)
    {
        if (is_array($x) || is_array($y)) {
            return self::evaluateArrayArguments([self::class, __FUNCTION__], $x, $y);
        }

try {
            $x = Helpers::validateNumericNullBool($x);
            $y = Helpers::validateNumericNullBool($y);
        } catch (Exception $e) {
            return $e->getMessage();
        }

// Validate parameters
        if (!$x && !$y) {
            return ExcelError::NAN();
        }
        if (!$x && $y < 0.0) {
            return ExcelError::DIV0();
        }

// Return
        $result = $x ** $y;

return Helpers::numberOrNan($result);
    }

/**
     * PRODUCT.
     *
     * PRODUCT returns the product of all the values and cells referenced in the argument list.
     *
     * Excel Function:
     *        PRODUCT(value1[,value2[, ...]])
     *
     * @param mixed ...$args Data values
     *
     * @return float|string
     */
    public static function product(...$args)
    {
        $args = array_filter(
            Functions::flattenArray($args),
            function ($value) {
                return $value !== null;
            }
        );

// Return value
        $returnValue = (count($args) === 0) ? 0.0 : 1.0;

// Loop through arguments
        foreach ($args as $arg) {
            // Is it a numeric value?
            if (is_numeric($arg)) {
                $returnValue *= $arg;
            } else {
                return ExcelError::throwError($arg);
            }
        }

return (float) $returnValue;
    }

/**
     * QUOTIENT.
     *
     * QUOTIENT function returns the integer portion of a division. Numerator is the divided number
     *        and denominator is the divisor.
     *
     * Excel Function:
     *        QUOTIENT(value1,value2)
     *
     * @param mixed $numerator Expect float|int
     *                      Or can be an array of values
     * @param mixed $denominator Expect float|int
     *                      Or can be an array of values
     *
     * @return array|int|string
     *         If an array of numbers is passed as an argument, then the returned result will also be an array
     *            with the same dimensions
     */
    public static function quotient($numerator, $denominator)
    {
        if (is_array($numerator) || is_array($denominator)) {
            return self::evaluateArrayArguments([self::class, __FUNCTION__], $numerator, $denominator);
        }

try {
            $numerator = Helpers::validateNumericNullSubstitution($numerator, 0);
            $denominator = Helpers::validateNumericNullSubstitution($denominator, 0);
            Helpers::validateNotZero($denominator);
        } catch (Exception $e) {
            return $e->getMessage();
        }

return (int) ($numerator / $denominator);
    }
}