<?php

namespace PhpOffice\PhpSpreadsheet\Calculation;


< use Exception;
< use Matrix\Exception as MatrixException;
< use Matrix\Matrix;
< 



> /**
>  * @deprecated 1.18.0
>  */


class MathTrig
{

<     //
<     //    Private method to return an array of the factors of the input value
<     //
<     private static function factors($value)
<     {
<         $startVal = floor(sqrt($value));
< 
<         $factorArray = [];
<         for ($i = $startVal; $i > 1; --$i) {
<             if (($value % $i) == 0) {
<                 $factorArray = array_merge($factorArray, self::factors($value / $i));
<                 $factorArray = array_merge($factorArray, self::factors($i));
<                 if ($i <= sqrt($value)) {
<                     break;
<                 }
<             }
<         }
<         if (!empty($factorArray)) {
<             rsort($factorArray);
< 
<             return $factorArray;
<         }
< 
<         return [(int) $value];
<     }
< 
<     private static function romanCut($num, $n)
<     {
<         return ($num - ($num % $n)) / $n;
<     }
< 


    /**
     * ARABIC.
     *
     * Converts a Roman numeral to an Arabic numeral.
     *
     * Excel Function:
     *        ARABIC(text)
     *

<      * @param string $roman



>      * @deprecated 1.18.0
>      *      Use the evaluate method in the MathTrig\Arabic class instead
>      * @see MathTrig\Arabic::evaluate()


     *

<      * @return int|string the arabic numberal contrived from the roman numeral
<      */
<     public static function ARABIC($roman)
<     {
<         // An empty string should return 0
<         $roman = substr(trim(strtoupper((string) Functions::flattenSingleValue($roman))), 0, 255);
<         if ($roman === '') {
<             return 0;
<         }
< 
<         // Convert the roman numeral to an arabic number
<         $negativeNumber = $roman[0] === '-';
<         if ($negativeNumber) {
<             $roman = substr($roman, 1);
<         }
< 
<         try {
<             $arabic = self::calculateArabic(str_split($roman));
<         } catch (Exception $e) {
<             return Functions::VALUE(); // Invalid character detected
<         }
< 
<         if ($negativeNumber) {
<             $arabic *= -1; // The number should be negative
<         }
< 
<         return $arabic;
<     }
< 
<     /**
<      * Recursively calculate the arabic value of a roman numeral.
<      *
<      * @param int $sum
<      * @param int $subtract



>      * @param array|string $roman


     *

<      * @return int



>      * @return array|int|string the arabic numberal contrived from the roman numeral


     */

<     protected static function calculateArabic(array $roman, &$sum = 0, $subtract = 0)



>     public static function ARABIC($roman)


    {

<         $lookup = [
<             'M' => 1000,
<             'D' => 500,
<             'C' => 100,
<             'L' => 50,
<             'X' => 10,
<             'V' => 5,
<             'I' => 1,
<         ];
< 
<         $numeral = array_shift($roman);
<         if (!isset($lookup[$numeral])) {
<             throw new Exception('Invalid character detected');
<         }
< 
<         $arabic = $lookup[$numeral];
<         if (count($roman) > 0 && isset($lookup[$roman[0]]) && $arabic < $lookup[$roman[0]]) {
<             $subtract += $arabic;
<         } else {
<             $sum += ($arabic - $subtract);
<             $subtract = 0;
<         }
< 
<         if (count($roman) > 0) {
<             self::calculateArabic($roman, $sum, $subtract);
<         }
< 
<         return $sum;



>         return MathTrig\Arabic::evaluate($roman);


    }

    /**
     * ATAN2.
     *
     * This function calculates the arc tangent of the two variables x and y. It is similar to
     *        calculating the arc tangent of y ÷ x, except that the signs of both arguments are used
     *        to determine the quadrant of the result.
     * The arctangent is the angle from the x-axis to a line containing the origin (0, 0) and a
     *        point with coordinates (xCoordinate, yCoordinate). The angle is given in radians between
     *        -pi and pi, excluding -pi.
     *
     * Note that the Excel ATAN2() function accepts its arguments in the reverse order to the standard
     *        PHP atan2() function, so we need to reverse them here before calling the PHP atan() function.
     *
     * Excel Function:
     *        ATAN2(xCoordinate,yCoordinate)
     *

<      * @param float $xCoordinate the x-coordinate of the point
<      * @param float $yCoordinate the y-coordinate of the point



>      * @deprecated 1.18.0
>      *      Use the atan2 method in the MathTrig\Trig\Tangent class instead
>      * @see MathTrig\Trig\Tangent::atan2()


     *

<      * @return float|string the inverse tangent of the specified x- and y-coordinates, or a string containing an error



>      * @param array|float $xCoordinate the x-coordinate of the point
>      * @param array|float $yCoordinate the y-coordinate of the point
>      *
>      * @return array|float|string the inverse tangent of the specified x- and y-coordinates, or a string containing an error


     */
    public static function ATAN2($xCoordinate = null, $yCoordinate = null)
    {

<         $xCoordinate = Functions::flattenSingleValue($xCoordinate);
<         $yCoordinate = Functions::flattenSingleValue($yCoordinate);
< 
<         $xCoordinate = ($xCoordinate !== null) ? $xCoordinate : 0.0;
<         $yCoordinate = ($yCoordinate !== null) ? $yCoordinate : 0.0;
< 
<         if (
<             ((is_numeric($xCoordinate)) || (is_bool($xCoordinate))) &&
<             ((is_numeric($yCoordinate))) || (is_bool($yCoordinate))
<         ) {
<             $xCoordinate = (float) $xCoordinate;
<             $yCoordinate = (float) $yCoordinate;
< 
<             if (($xCoordinate == 0) && ($yCoordinate == 0)) {
<                 return Functions::DIV0();
<             }
< 
<             return atan2($yCoordinate, $xCoordinate);
<         }
< 
<         return Functions::VALUE();



>         return MathTrig\Trig\Tangent::atan2($xCoordinate, $yCoordinate);


    }

    /**
     * BASE.
     *
     * Converts a number into a text representation with the given radix (base).
     *
     * Excel Function:
     *        BASE(Number, Radix [Min_length])
     *

>      * @deprecated 1.18.0
     * @param float $number
>      *      Use the evaluate method in the MathTrig\Base class instead
     * @param float $radix
>      * @see MathTrig\Base::evaluate()
     * @param int $minLength
>      *


     *

<      * @return string the text representation with the given radix (base)



>      * @return array|string the text representation with the given radix (base)


     */
    public static function BASE($number, $radix, $minLength = null)
    {

<         $number = Functions::flattenSingleValue($number);
<         $radix = Functions::flattenSingleValue($radix);
<         $minLength = Functions::flattenSingleValue($minLength);
< 
<         if (is_numeric($number) && is_numeric($radix) && ($minLength === null || is_numeric($minLength))) {
<             // Truncate to an integer
<             $number = (int) $number;
<             $radix = (int) $radix;
<             $minLength = (int) $minLength;
< 
<             if ($number < 0 || $number >= 2 ** 53 || $radix < 2 || $radix > 36) {
<                 return Functions::NAN(); // Numeric range constraints
<             }
< 
<             $outcome = strtoupper((string) base_convert($number, 10, $radix));
<             if ($minLength !== null) {
<                 $outcome = str_pad($outcome, $minLength, '0', STR_PAD_LEFT); // String padding
<             }
< 
<             return $outcome;
<         }
< 
<         return Functions::VALUE();



>         return MathTrig\Base::evaluate($number, $radix, $minLength);


    }

    /**
     * CEILING.
     *
     * Returns number rounded up, away from zero, to the nearest multiple of significance.
     *        For example, if you want to avoid using pennies in your prices and your product is
     *        priced at $4.42, use the formula =CEILING(4.42,0.05) to round prices up to the
     *        nearest nickel.
     *
     * Excel Function:
     *        CEILING(number[,significance])
     *

>      * @deprecated 1.17.0
     * @param float $number the number you want to round
>      *      Use the ceiling() method in the MathTrig\Ceiling class instead
     * @param float $significance the multiple to which you want to round
>      * @see MathTrig\Ceiling::ceiling()
     *
>      *



<      * @return float|string Rounded Number, or a string containing an error



>      * @return array|float|string Rounded Number, or a string containing an error


     */
    public static function CEILING($number, $significance = null)
    {

<         $number = Functions::flattenSingleValue($number);
<         $significance = Functions::flattenSingleValue($significance);
< 
<         if (
<             ($significance === null) &&
<             (Functions::getCompatibilityMode() == Functions::COMPATIBILITY_GNUMERIC)
<         ) {
<             $significance = $number / abs($number);
<         }
< 
<         if ((is_numeric($number)) && (is_numeric($significance))) {
<             if (($number == 0.0) || ($significance == 0.0)) {
<                 return 0.0;
<             } elseif (self::SIGN($number) == self::SIGN($significance)) {
<                 return ceil($number / $significance) * $significance;
<             }
< 
<             return Functions::NAN();
<         }
< 
<         return Functions::VALUE();



>         return MathTrig\Ceiling::ceiling($number, $significance);


    }

    /**
     * COMBIN.
     *
     * Returns the number of combinations for a given number of items. Use COMBIN to
     *        determine the total possible number of groups for a given number of items.
     *
     * Excel Function:
     *        COMBIN(numObjs,numInSet)
     *

<      * @param int $numObjs Number of different objects
<      * @param int $numInSet Number of objects in each combination



>      * @deprecated 1.18.0
>      *      Use the withoutRepetition() method in the MathTrig\Combinations class instead
>      * @see MathTrig\Combinations::withoutRepetition()


     *

<      * @return int|string Number of combinations, or a string containing an error



>      * @param array|int $numObjs Number of different objects
>      * @param array|int $numInSet Number of objects in each combination
>      *
>      * @return array|float|int|string Number of combinations, or a string containing an error


     */
    public static function COMBIN($numObjs, $numInSet)
    {

<         $numObjs = Functions::flattenSingleValue($numObjs);
<         $numInSet = Functions::flattenSingleValue($numInSet);
< 
<         if ((is_numeric($numObjs)) && (is_numeric($numInSet))) {
<             if ($numObjs < $numInSet) {
<                 return Functions::NAN();
<             } elseif ($numInSet < 0) {
<                 return Functions::NAN();
<             }
< 
<             return round(self::FACT($numObjs) / self::FACT($numObjs - $numInSet)) / self::FACT($numInSet);
<         }
< 
<         return Functions::VALUE();



>         return MathTrig\Combinations::withoutRepetition($numObjs, $numInSet);


    }

    /**
     * EVEN.
     *
     * Returns number rounded up to the nearest even integer.
     * You can use this function for processing items that come in twos. For example,
     *        a packing crate accepts rows of one or two items. The crate is full when
     *        the number of items, rounded up to the nearest two, matches the crate's
     *        capacity.
     *
     * Excel Function:
     *        EVEN(number)
     *

<      * @param float $number Number to round



>      * @deprecated 1.18.0
>      *      Use the even() method in the MathTrig\Round class instead
>      * @see MathTrig\Round::even()
>      *
>      * @param array|float $number Number to round


     *

<      * @return int|string Rounded Number, or a string containing an error



>      * @return array|float|int|string Rounded Number, or a string containing an error


     */
    public static function EVEN($number)
    {

<         $number = Functions::flattenSingleValue($number);
< 
<         if ($number === null) {
<             return 0;
<         } elseif (is_bool($number)) {
<             $number = (int) $number;
<         }
< 
<         if (is_numeric($number)) {
<             $significance = 2 * self::SIGN($number);
< 
<             return (int) self::CEILING($number, $significance);



>         return MathTrig\Round::even($number);


        }


<         return Functions::VALUE();



>     /**
>      * Helper function for Even.
>      *
>      * @deprecated 1.18.0
>      *      Use the evaluate() method in the MathTrig\Helpers class instead
>      * @see MathTrig\Helpers::getEven()
>      */
>     public static function getEven(float $number): int
>     {
>         return (int) MathTrig\Helpers::getEven($number);


    }

    /**
     * FACT.
     *
     * Returns the factorial of a number.
     * The factorial of a number is equal to 1*2*3*...* number.
     *
     * Excel Function:
     *        FACT(factVal)
     *

<      * @param float $factVal Factorial Value



>      * @deprecated 1.18.0
>      *      Use the fact() method in the MathTrig\Factorial class instead
>      * @see MathTrig\Factorial::fact()
>      *
>      * @param array|float $factVal Factorial Value


     *

<      * @return int|string Factorial, or a string containing an error



>      * @return array|float|int|string Factorial, or a string containing an error


     */
    public static function FACT($factVal)
    {

<         $factVal = Functions::flattenSingleValue($factVal);
< 
<         if (is_numeric($factVal)) {
<             if ($factVal < 0) {
<                 return Functions::NAN();
<             }
<             $factLoop = floor($factVal);
<             if (
<                 (Functions::getCompatibilityMode() == Functions::COMPATIBILITY_GNUMERIC) &&
<                 ($factVal > $factLoop)
<             ) {
<                 return Functions::NAN();
<             }
< 
<             $factorial = 1;
<             while ($factLoop > 1) {
<                 $factorial *= $factLoop--;
<             }
< 
<             return $factorial;
<         }
< 
<         return Functions::VALUE();



>         return MathTrig\Factorial::fact($factVal);


    }

    /**
     * FACTDOUBLE.
     *
     * Returns the double factorial of a number.
     *
     * Excel Function:
     *        FACTDOUBLE(factVal)
     *

<      * @param float $factVal Factorial Value



>      * @deprecated 1.18.0
>      *      Use the factDouble() method in the MathTrig\Factorial class instead
>      * @see MathTrig\Factorial::factDouble()


     *

<      * @return int|string Double Factorial, or a string containing an error



>      * @param array|float $factVal Factorial Value
>      *
>      * @return array|float|int|string Double Factorial, or a string containing an error


     */
    public static function FACTDOUBLE($factVal)
    {

<         $factLoop = Functions::flattenSingleValue($factVal);
< 
<         if (is_numeric($factLoop)) {
<             $factLoop = floor($factLoop);
<             if ($factVal < 0) {
<                 return Functions::NAN();
<             }
<             $factorial = 1;
<             while ($factLoop > 1) {
<                 $factorial *= $factLoop--;
<                 --$factLoop;
<             }
< 
<             return $factorial;
<         }
< 
<         return Functions::VALUE();



>         return MathTrig\Factorial::factDouble($factVal);


    }

    /**
     * FLOOR.
     *
     * Rounds number down, toward zero, to the nearest multiple of significance.
     *
     * Excel Function:
     *        FLOOR(number[,significance])
     *

>      * @deprecated 1.17.0
     * @param float $number Number to round
>      *      Use the floor() method in the MathTrig\Floor class instead
     * @param float $significance Significance
>      * @see MathTrig\Floor::floor()
     *
>      *



<      * @return float|string Rounded Number, or a string containing an error



>      * @return array|float|string Rounded Number, or a string containing an error


     */
    public static function FLOOR($number, $significance = null)
    {

<         $number = Functions::flattenSingleValue($number);
<         $significance = Functions::flattenSingleValue($significance);
< 
<         if (
<             ($significance === null) &&
<             (Functions::getCompatibilityMode() == Functions::COMPATIBILITY_GNUMERIC)
<         ) {
<             $significance = $number / abs($number);
<         }
< 
<         if ((is_numeric($number)) && (is_numeric($significance))) {
<             if ($significance == 0.0) {
<                 return Functions::DIV0();
<             } elseif ($number == 0.0) {
<                 return 0.0;
<             } elseif (self::SIGN($significance) == 1) {
<                 return floor($number / $significance) * $significance;
<             } elseif (self::SIGN($number) == -1 && self::SIGN($significance) == -1) {
<                 return floor($number / $significance) * $significance;
<             }
< 
<             return Functions::NAN();
<         }
< 
<         return Functions::VALUE();



>         return MathTrig\Floor::floor($number, $significance);


    }

    /**
     * FLOOR.MATH.
     *
     * Round a number down to the nearest integer or to the nearest multiple of significance.
     *
     * Excel Function:
     *        FLOOR.MATH(number[,significance[,mode]])
     *

>      * @deprecated 1.17.0
     * @param float $number Number to round
>      *      Use the math() method in the MathTrig\Floor class instead
     * @param float $significance Significance
>      * @see MathTrig\Floor::math()
     * @param int $mode direction to round negative numbers
>      *


     *

<      * @return float|string Rounded Number, or a string containing an error



>      * @return array|float|string Rounded Number, or a string containing an error


     */
    public static function FLOORMATH($number, $significance = null, $mode = 0)
    {

<         $number = Functions::flattenSingleValue($number);
<         $significance = Functions::flattenSingleValue($significance);
<         $mode = Functions::flattenSingleValue($mode);
< 
<         if (is_numeric($number) && $significance === null) {
<             $significance = $number / abs($number);
<         }
< 
<         if (is_numeric($number) && is_numeric($significance) && is_numeric($mode)) {
<             if ($significance == 0.0) {
<                 return Functions::DIV0();
<             } elseif ($number == 0.0) {
<                 return 0.0;
<             } elseif (self::SIGN($significance) == -1 || (self::SIGN($number) == -1 && !empty($mode))) {
<                 return ceil($number / $significance) * $significance;
<             }
< 
<             return floor($number / $significance) * $significance;
<         }
< 
<         return Functions::VALUE();



>         return MathTrig\Floor::math($number, $significance, $mode);


    }

    /**
     * FLOOR.PRECISE.
     *
     * Rounds number down, toward zero, to the nearest multiple of significance.
     *
     * Excel Function:
     *        FLOOR.PRECISE(number[,significance])
     *

>      * @deprecated 1.17.0
     * @param float $number Number to round
>      *      Use the precise() method in the MathTrig\Floor class instead
     * @param float $significance Significance
>      * @see MathTrig\Floor::precise()
     *
>      *



<      * @return float|string Rounded Number, or a string containing an error



>      * @return array|float|string Rounded Number, or a string containing an error


     */
    public static function FLOORPRECISE($number, $significance = 1)
    {

<         $number = Functions::flattenSingleValue($number);
<         $significance = Functions::flattenSingleValue($significance);
< 
<         if ((is_numeric($number)) && (is_numeric($significance))) {
<             if ($significance == 0.0) {
<                 return Functions::DIV0();
<             } elseif ($number == 0.0) {
<                 return 0.0;
<             }
< 
<             return floor($number / abs($significance)) * abs($significance);



>         return MathTrig\Floor::precise($number, $significance);


        }


<         return Functions::VALUE();
<     }
< 
<     private static function evaluateGCD($a, $b)



>     /**
>      * INT.
>      *
>      * Casts a floating point value to an integer
>      *
>      * Excel Function:
>      *        INT(number)
>      *
>      * @deprecated 1.17.0
>      *      Use the evaluate() method in the MathTrig\IntClass class instead
>      * @see MathTrig\IntClass::evaluate()
>      *
>      * @param array|float $number Number to cast to an integer
>      *
>      * @return array|int|string Integer value, or a string containing an error
>      */
>     public static function INT($number)


    {

<         return $b ? self::evaluateGCD($b, $a % $b) : $a;



>         return MathTrig\IntClass::evaluate($number);


    }

    /**
     * GCD.
     *
     * Returns the greatest common divisor of a series of numbers.
     * The greatest common divisor is the largest integer that divides both
     *        number1 and number2 without a remainder.
     *
     * Excel Function:
     *        GCD(number1[,number2[, ...]])
     *

>      * @deprecated 1.18.0
     * @param mixed ...$args Data values
>      *      Use the evaluate() method in the MathTrig\Gcd class instead
     *
>      * @see MathTrig\Gcd::evaluate()
     * @return int|mixed|string Greatest Common Divisor, or a string containing an error
>      *


     */
    public static function GCD(...$args)
    {

<         $args = Functions::flattenArray($args);
<         // Loop through arguments
<         foreach (Functions::flattenArray($args) as $value) {
<             if (!is_numeric($value)) {
<                 return Functions::VALUE();
<             } elseif ($value < 0) {
<                 return Functions::NAN();
<             }
<         }
< 
<         $gcd = (int) array_pop($args);
<         do {
<             $gcd = self::evaluateGCD($gcd, (int) array_pop($args));
<         } while (!empty($args));
< 
<         return $gcd;
<     }
< 
<     /**
<      * INT.
<      *
<      * Casts a floating point value to an integer
<      *
<      * Excel Function:
<      *        INT(number)
<      *
<      * @param float $number Number to cast to an integer
<      *
<      * @return int|string Integer value, or a string containing an error
<      */
<     public static function INT($number)
<     {
<         $number = Functions::flattenSingleValue($number);
< 
<         if ($number === null) {
<             return 0;
<         } elseif (is_bool($number)) {
<             return (int) $number;
<         }
<         if (is_numeric($number)) {
<             return (int) floor($number);
<         }
< 
<         return Functions::VALUE();



>         return MathTrig\Gcd::evaluate(...$args);


    }

    /**
     * LCM.
     *
     * Returns the lowest common multiplier of a series of numbers
     * The least common multiple is the smallest positive integer that is a multiple
     * of all integer arguments number1, number2, and so on. Use LCM to add fractions
     * with different denominators.
     *
     * Excel Function:
     *        LCM(number1[,number2[, ...]])
     *

>      * @deprecated 1.18.0
     * @param mixed ...$args Data values
>      *      Use the evaluate() method in the MathTrig\Lcm class instead
     *
>      * @see MathTrig\Lcm::evaluate()
     * @return int|string Lowest Common Multiplier, or a string containing an error
>      *


     */
    public static function LCM(...$args)
    {

<         $returnValue = 1;
<         $allPoweredFactors = [];
<         // Loop through arguments
<         foreach (Functions::flattenArray($args) as $value) {
<             if (!is_numeric($value)) {
<                 return Functions::VALUE();
<             }
<             if ($value == 0) {
<                 return 0;
<             } elseif ($value < 0) {
<                 return Functions::NAN();
<             }
<             $myFactors = self::factors(floor($value));
<             $myCountedFactors = array_count_values($myFactors);
<             $myPoweredFactors = [];
<             foreach ($myCountedFactors as $myCountedFactor => $myCountedPower) {
<                 $myPoweredFactors[$myCountedFactor] = $myCountedFactor ** $myCountedPower;
<             }
<             foreach ($myPoweredFactors as $myPoweredValue => $myPoweredFactor) {
<                 if (isset($allPoweredFactors[$myPoweredValue])) {
<                     if ($allPoweredFactors[$myPoweredValue] < $myPoweredFactor) {
<                         $allPoweredFactors[$myPoweredValue] = $myPoweredFactor;
<                     }
<                 } else {
<                     $allPoweredFactors[$myPoweredValue] = $myPoweredFactor;
<                 }
<             }
<         }
<         foreach ($allPoweredFactors as $allPoweredFactor) {
<             $returnValue *= (int) $allPoweredFactor;
<         }
< 
<         return $returnValue;



>         return MathTrig\Lcm::evaluate(...$args);


    }

    /**
     * LOG_BASE.
     *
     * Returns the logarithm of a number to a specified base. The default base is 10.
     *
     * Excel Function:
     *        LOG(number[,base])
     *

>      * @deprecated 1.18.0
     * @param float $number The positive real number for which you want the logarithm
>      *      Use the withBase() method in the MathTrig\Logarithms class instead
     * @param float $base The base of the logarithm. If base is omitted, it is assumed to be 10.
>      * @see MathTrig\Logarithms::withBase()
     *
>      *



<      * @return float|string The result, or a string containing an error



>      * @return array|float|string The result, or a string containing an error


     */

<     public static function logBase($number = null, $base = 10)



>     public static function logBase($number, $base = 10)


    {

<         $number = Functions::flattenSingleValue($number);
<         $base = ($base === null) ? 10 : (float) Functions::flattenSingleValue($base);
< 
<         if ((!is_numeric($base)) || (!is_numeric($number))) {
<             return Functions::VALUE();
<         }
<         if (($base <= 0) || ($number <= 0)) {
<             return Functions::NAN();
<         }
< 
<         return log($number, $base);



>         return MathTrig\Logarithms::withBase($number, $base);


    }

    /**
     * MDETERM.
     *
     * Returns the matrix determinant of an array.
     *
     * Excel Function:
     *        MDETERM(array)
     *

>      * @deprecated 1.18.0
     * @param array $matrixValues A matrix of values
>      *      Use the determinant() method in the MathTrig\MatrixFunctions class instead
     *
>      * @see MathTrig\MatrixFunctions::determinant()
     * @return float|string The result, or a string containing an error
>      *


     */
    public static function MDETERM($matrixValues)
    {

<         $matrixData = [];
<         if (!is_array($matrixValues)) {
<             $matrixValues = [[$matrixValues]];
<         }
< 
<         $row = $maxColumn = 0;
<         foreach ($matrixValues as $matrixRow) {
<             if (!is_array($matrixRow)) {
<                 $matrixRow = [$matrixRow];
<             }
<             $column = 0;
<             foreach ($matrixRow as $matrixCell) {
<                 if ((is_string($matrixCell)) || ($matrixCell === null)) {
<                     return Functions::VALUE();
<                 }
<                 $matrixData[$row][$column] = $matrixCell;
<                 ++$column;
<             }
<             if ($column > $maxColumn) {
<                 $maxColumn = $column;
<             }
<             ++$row;
<         }
< 
<         $matrix = new Matrix($matrixData);
<         if (!$matrix->isSquare()) {
<             return Functions::VALUE();
<         }
< 
<         try {
<             return $matrix->determinant();
<         } catch (MatrixException $ex) {
<             return Functions::VALUE();
<         }



>         return MathTrig\MatrixFunctions::determinant($matrixValues);


    }

    /**
     * MINVERSE.
     *
     * Returns the inverse matrix for the matrix stored in an array.
     *
     * Excel Function:
     *        MINVERSE(array)
     *

>      * @deprecated 1.18.0
     * @param array $matrixValues A matrix of values
>      *      Use the inverse() method in the MathTrig\MatrixFunctions class instead
     *
>      * @see MathTrig\MatrixFunctions::inverse()
     * @return array|string The result, or a string containing an error
>      *


     */
    public static function MINVERSE($matrixValues)
    {

<         $matrixData = [];
<         if (!is_array($matrixValues)) {
<             $matrixValues = [[$matrixValues]];
<         }
< 
<         $row = $maxColumn = 0;
<         foreach ($matrixValues as $matrixRow) {
<             if (!is_array($matrixRow)) {
<                 $matrixRow = [$matrixRow];
<             }
<             $column = 0;
<             foreach ($matrixRow as $matrixCell) {
<                 if ((is_string($matrixCell)) || ($matrixCell === null)) {
<                     return Functions::VALUE();
<                 }
<                 $matrixData[$row][$column] = $matrixCell;
<                 ++$column;
<             }
<             if ($column > $maxColumn) {
<                 $maxColumn = $column;
<             }
<             ++$row;
<         }
< 
<         $matrix = new Matrix($matrixData);
<         if (!$matrix->isSquare()) {
<             return Functions::VALUE();
<         }
< 
<         if ($matrix->determinant() == 0.0) {
<             return Functions::NAN();
<         }
< 
<         try {
<             return $matrix->inverse()->toArray();
<         } catch (MatrixException $ex) {
<             return Functions::VALUE();
<         }



>         return MathTrig\MatrixFunctions::inverse($matrixValues);


    }

    /**
     * MMULT.
     *

>      * @deprecated 1.18.0
     * @param array $matrixData1 A matrix of values
>      *      Use the multiply() method in the MathTrig\MatrixFunctions class instead
     * @param array $matrixData2 A matrix of values
>      * @see MathTrig\MatrixFunctions::multiply()
     *
>      *


     * @return array|string The result, or a string containing an error
     */
    public static function MMULT($matrixData1, $matrixData2)
    {

<         $matrixAData = $matrixBData = [];
<         if (!is_array($matrixData1)) {
<             $matrixData1 = [[$matrixData1]];
<         }
<         if (!is_array($matrixData2)) {
<             $matrixData2 = [[$matrixData2]];
<         }
< 
<         try {
<             $rowA = 0;
<             foreach ($matrixData1 as $matrixRow) {
<                 if (!is_array($matrixRow)) {
<                     $matrixRow = [$matrixRow];
<                 }
<                 $columnA = 0;
<                 foreach ($matrixRow as $matrixCell) {
<                     if ((!is_numeric($matrixCell)) || ($matrixCell === null)) {
<                         return Functions::VALUE();
<                     }
<                     $matrixAData[$rowA][$columnA] = $matrixCell;
<                     ++$columnA;
<                 }
<                 ++$rowA;
<             }
<             $matrixA = new Matrix($matrixAData);
<             $rowB = 0;
<             foreach ($matrixData2 as $matrixRow) {
<                 if (!is_array($matrixRow)) {
<                     $matrixRow = [$matrixRow];
<                 }
<                 $columnB = 0;
<                 foreach ($matrixRow as $matrixCell) {
<                     if ((!is_numeric($matrixCell)) || ($matrixCell === null)) {
<                         return Functions::VALUE();
<                     }
<                     $matrixBData[$rowB][$columnB] = $matrixCell;
<                     ++$columnB;
<                 }
<                 ++$rowB;
<             }
<             $matrixB = new Matrix($matrixBData);
< 
<             if ($columnA != $rowB) {
<                 return Functions::VALUE();
<             }
< 
<             return $matrixA->multiply($matrixB)->toArray();
<         } catch (MatrixException $ex) {
<             return Functions::VALUE();
<         }



>         return MathTrig\MatrixFunctions::multiply($matrixData1, $matrixData2);


    }

    /**
     * MOD.
     *

>      * @deprecated 1.18.0
     * @param int $a Dividend
>      *      Use the mod() method in the MathTrig\Operations class instead
     * @param int $b Divisor
>      * @see MathTrig\Operations::mod()
     *
>      *



<      * @return int|string Remainder, or a string containing an error



>      * @return array|float|int|string Remainder, or a string containing an error


     */
    public static function MOD($a = 1, $b = 1)
    {

<         $a = (float) Functions::flattenSingleValue($a);
<         $b = (float) Functions::flattenSingleValue($b);
< 
<         if ($b == 0.0) {
<             return Functions::DIV0();
<         } elseif (($a < 0.0) && ($b > 0.0)) {
<             return $b - fmod(abs($a), $b);
<         } elseif (($a > 0.0) && ($b < 0.0)) {
<             return $b + fmod($a, abs($b));
<         }
< 
<         return fmod($a, $b);



>         return MathTrig\Operations::mod($a, $b);


    }

    /**
     * MROUND.
     *
     * Rounds a number to the nearest multiple of a specified value
     *

>      * @deprecated 1.17.0
     * @param float $number Number to round
>      *      Use the multiple() method in the MathTrig\Mround class instead
     * @param int $multiple Multiple to which you want to round $number
>      * @see MathTrig\Round::multiple()
     *
>      *



<      * @param int $multiple Multiple to which you want to round $number



>      * @param array|int $multiple Multiple to which you want to round $number



<      * @return float|string Rounded Number, or a string containing an error



>      * @return array|float|string Rounded Number, or a string containing an error


    public static function MROUND($number, $multiple)
    {

<         $number = Functions::flattenSingleValue($number);
<         $multiple = Functions::flattenSingleValue($multiple);
< 
<         if ((is_numeric($number)) && (is_numeric($multiple))) {
<             if ($multiple == 0) {
<                 return 0;
<             }
<             if ((self::SIGN($number)) == (self::SIGN($multiple))) {
<                 $multiplier = 1 / $multiple;
< 
<                 return round($number * $multiplier) / $multiplier;
<             }
< 
<             return Functions::NAN();
<         }
< 
<         return Functions::VALUE();



>         return MathTrig\Round::multiple($number, $multiple);


    }

    /**
     * MULTINOMIAL.
     *
     * Returns the ratio of the factorial of a sum of values to the product of factorials.
     *

>      * @deprecated 1.18.0
     * @param mixed[] $args An array of mixed values for the Data Series
>      *      Use the multinomial method in the MathTrig\Factorial class instead
     *
>      * @see MathTrig\Factorial::multinomial()
     * @return float|string The result, or a string containing an error
>      *


     */
    public static function MULTINOMIAL(...$args)
    {

<         $summer = 0;
<         $divisor = 1;
<         // Loop through arguments
<         foreach (Functions::flattenArray($args) as $arg) {
<             // Is it a numeric value?
<             if (is_numeric($arg)) {
<                 if ($arg < 1) {
<                     return Functions::NAN();
<                 }
<                 $summer += floor($arg);
<                 $divisor *= self::FACT($arg);
<             } else {
<                 return Functions::VALUE();
<             }
<         }
< 
<         // Return
<         if ($summer > 0) {
<             $summer = self::FACT($summer);
< 
<             return $summer / $divisor;
<         }
< 
<         return 0;



>         return MathTrig\Factorial::multinomial(...$args);


    }

    /**
     * ODD.
     *
     * Returns number rounded up to the nearest odd integer.
     *

<      * @param float $number Number to round



>      * @deprecated 1.18.0
>      *      Use the odd method in the MathTrig\Round class instead
>      * @see MathTrig\Round::odd()
>      *
>      * @param array|float $number Number to round


     *

<      * @return int|string Rounded Number, or a string containing an error



>      * @return array|float|int|string Rounded Number, or a string containing an error


     */
    public static function ODD($number)
    {

<         $number = Functions::flattenSingleValue($number);
< 
<         if ($number === null) {
<             return 1;
<         } elseif (is_bool($number)) {
<             return 1;
<         } elseif (is_numeric($number)) {
<             $significance = self::SIGN($number);
<             if ($significance == 0) {
<                 return 1;
<             }
< 
<             $result = self::CEILING($number, $significance);
<             if ($result == self::EVEN($result)) {
<                 $result += $significance;
<             }
< 
<             return (int) $result;
<         }
< 
<         return Functions::VALUE();



>         return MathTrig\Round::odd($number);


    }

    /**
     * POWER.
     *
     * Computes x raised to the power y.
     *

>      * @deprecated 1.18.0
     * @param float $x
>      *      Use the evaluate method in the MathTrig\Power class instead
     * @param float $y
>      * @see MathTrig\Operations::power()
     *
>      *



<      * @return float|string The result, or a string containing an error



>      * @return array|float|int|string The result, or a string containing an error


     */
    public static function POWER($x = 0, $y = 2)
    {

<         $x = Functions::flattenSingleValue($x);
<         $y = Functions::flattenSingleValue($y);
< 
<         // Validate parameters
<         if ($x == 0.0 && $y == 0.0) {
<             return Functions::NAN();
<         } elseif ($x == 0.0 && $y < 0.0) {
<             return Functions::DIV0();
<         }
< 
<         // Return
<         $result = $x ** $y;
< 
<         return (!is_nan($result) && !is_infinite($result)) ? $result : Functions::NAN();



>         return MathTrig\Operations::power($x, $y);


    }

    /**
     * PRODUCT.
     *
     * PRODUCT returns the product of all the values and cells referenced in the argument list.
     *

>      * @deprecated 1.18.0
     * Excel Function:
>      *      Use the product method in the MathTrig\Operations class instead
     *        PRODUCT(value1[,value2[, ...]])
>      * @see MathTrig\Operations::product()
     *
>      *


     * @param mixed ...$args Data values
     *

<      * @return float



>      * @return float|string


     */
    public static function PRODUCT(...$args)
    {

<         // Return value
<         $returnValue = null;
< 
<         // Loop through arguments
<         foreach (Functions::flattenArray($args) as $arg) {
<             // Is it a numeric value?
<             if ((is_numeric($arg)) && (!is_string($arg))) {
<                 if ($returnValue === null) {
<                     $returnValue = $arg;
<                 } else {
<                     $returnValue *= $arg;
<                 }
<             }
<         }
< 
<         // Return
<         if ($returnValue === null) {
<             return 0;
<         }
< 
<         return $returnValue;



>         return MathTrig\Operations::product(...$args);


    }

    /**
     * QUOTIENT.
     *
     * QUOTIENT function returns the integer portion of a division. Numerator is the divided number
     *        and denominator is the divisor.
     *

>      * @deprecated 1.18.0
     * Excel Function:
>      *      Use the quotient method in the MathTrig\Operations class instead
     *        QUOTIENT(value1[,value2[, ...]])
>      * @see MathTrig\Operations::quotient()
     *
>      *



<      * @param mixed ...$args Data values



>      * @param mixed $numerator
>      * @param mixed $denominator


     *

<      * @return float



>      * @return array|int|string


     */

<     public static function QUOTIENT(...$args)



>     public static function QUOTIENT($numerator, $denominator)


    {

<         // Return value
<         $returnValue = null;
< 
<         // Loop through arguments
<         foreach (Functions::flattenArray($args) as $arg) {
<             // Is it a numeric value?
<             if ((is_numeric($arg)) && (!is_string($arg))) {
<                 if ($returnValue === null) {
<                     $returnValue = ($arg == 0) ? 0 : $arg;
<                 } else {
<                     if (($returnValue == 0) || ($arg == 0)) {
<                         $returnValue = 0;
<                     } else {
<                         $returnValue /= $arg;
<                     }
<                 }
<             }
<         }
< 
<         // Return
<         return (int) $returnValue;



>         return MathTrig\Operations::quotient($numerator, $denominator);


    }

    /**

<      * RAND.



>      * RAND/RANDBETWEEN.
>      *
>      * @deprecated 1.18.0
>      *      Use the randBetween or randBetween method in the MathTrig\Random class instead
>      * @see MathTrig\Random::randBetween()


     *
     * @param int $min Minimal value
     * @param int $max Maximal value
     *

<      * @return int Random number



>      * @return array|float|int|string Random number


     */
    public static function RAND($min = 0, $max = 0)
    {

<         $min = Functions::flattenSingleValue($min);
<         $max = Functions::flattenSingleValue($max);
< 
<         if ($min == 0 && $max == 0) {
<             return (mt_rand(0, 10000000)) / 10000000;
<         }
< 
<         return mt_rand($min, $max);



>         return MathTrig\Random::randBetween($min, $max);


    }


>     /**
    public static function ROMAN($aValue, $style = 0)
>      * ROMAN.
    {
>      *
        $aValue = Functions::flattenSingleValue($aValue);
>      * Converts a number to Roman numeral
        $style = ($style === null) ? 0 : (int) Functions::flattenSingleValue($style);
>      *
        if ((!is_numeric($aValue)) || ($aValue < 0) || ($aValue >= 4000)) {
>      * @deprecated 1.17.0
            return Functions::VALUE();
>      *      Use the evaluate() method in the MathTrig\Roman class instead
        }
>      * @see MathTrig\Roman::evaluate()
        $aValue = (int) $aValue;
>      *
        if ($aValue == 0) {
>      * @param mixed $aValue Number to convert
            return '';
>      * @param mixed $style Number indicating one of five possible forms
        }
>      *

>      * @return array|string Roman numeral, or a string containing an error
        $mill = ['', 'M', 'MM', 'MMM', 'MMMM', 'MMMMM'];
>      */



<         $aValue = Functions::flattenSingleValue($aValue);
<         $style = ($style === null) ? 0 : (int) Functions::flattenSingleValue($style);
<         if ((!is_numeric($aValue)) || ($aValue < 0) || ($aValue >= 4000)) {
<             return Functions::VALUE();
<         }
<         $aValue = (int) $aValue;
<         if ($aValue == 0) {
<             return '';
<         }
< 
<         $mill = ['', 'M', 'MM', 'MMM', 'MMMM', 'MMMMM'];
<         $cent = ['', 'C', 'CC', 'CCC', 'CD', 'D', 'DC', 'DCC', 'DCCC', 'CM'];
<         $tens = ['', 'X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC'];
<         $ones = ['', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX'];
< 
<         $roman = '';
<         while ($aValue > 5999) {
<             $roman .= 'M';
<             $aValue -= 1000;
<         }
<         $m = self::romanCut($aValue, 1000);
<         $aValue %= 1000;
<         $c = self::romanCut($aValue, 100);
<         $aValue %= 100;
<         $t = self::romanCut($aValue, 10);
<         $aValue %= 10;
< 
<         return $roman . $mill[$m] . $cent[$c] . $tens[$t] . $ones[$aValue];



>         return MathTrig\Roman::evaluate($aValue, $style);



<      * @param float $number Number to round
<      * @param int $digits Number of digits to which you want to round $number



>      * @deprecated 1.17.0
>      *      Use the up() method in the MathTrig\Round class instead
>      * @see MathTrig\Round::up()
>      *
>      * @param array|float $number Number to round
>      * @param array|int $digits Number of digits to which you want to round $number



<      * @return float|string Rounded Number, or a string containing an error



>      * @return array|float|string Rounded Number, or a string containing an error



<         $number = Functions::flattenSingleValue($number);
<         $digits = Functions::flattenSingleValue($digits);
< 
<         if ((is_numeric($number)) && (is_numeric($digits))) {
<             if ($number == 0.0) {
<                 return 0.0;
<             }
< 
<             if ($number < 0.0) {
<                 return round($number - 0.5 * 0.1 ** $digits, $digits, PHP_ROUND_HALF_DOWN);
<             }
< 
<             return round($number + 0.5 * 0.1 ** $digits, $digits, PHP_ROUND_HALF_DOWN);
<         }
< 
<         return Functions::VALUE();



>         return MathTrig\Round::up($number, $digits);


    }

    /**
     * ROUNDDOWN.
     *
     * Rounds a number down to a specified number of decimal places
     *

<      * @param float $number Number to round
<      * @param int $digits Number of digits to which you want to round $number



>      * @deprecated 1.17.0
>      *      Use the down() method in the MathTrig\Round class instead
>      * @see MathTrig\Round::down()
>      *
>      * @param array|float $number Number to round
>      * @param array|int $digits Number of digits to which you want to round $number


     *

<      * @return float|string Rounded Number, or a string containing an error



>      * @return array|float|string Rounded Number, or a string containing an error


     */
    public static function ROUNDDOWN($number, $digits)
    {

<         $number = Functions::flattenSingleValue($number);
<         $digits = Functions::flattenSingleValue($digits);
< 
<         if ((is_numeric($number)) && (is_numeric($digits))) {
<             if ($number == 0.0) {
<                 return 0.0;
<             }
< 
<             if ($number < 0.0) {
<                 return round($number + 0.5 * 0.1 ** $digits, $digits, PHP_ROUND_HALF_UP);
<             }
< 
<             return round($number - 0.5 * 0.1 ** $digits, $digits, PHP_ROUND_HALF_UP);
<         }
< 
<         return Functions::VALUE();



>         return MathTrig\Round::down($number, $digits);


    }

    /**
     * SERIESSUM.
     *
     * Returns the sum of a power series
     *

<      * @param mixed[] $args An array of mixed values for the Data Series



>      * @deprecated 1.18.0
>      *      Use the evaluate method in the MathTrig\SeriesSum class instead
>      * @see MathTrig\SeriesSum::evaluate()


     *

<      * @return float|string The result, or a string containing an error



>      * @param mixed $x Input value
>      * @param mixed $n Initial power
>      * @param mixed $m Step
>      * @param mixed[] $args An array of coefficients for the Data Series
>      *
>      * @return array|float|string The result, or a string containing an error


     */

<     public static function SERIESSUM(...$args)



>     public static function SERIESSUM($x, $n, $m, ...$args)


    {

<         $returnValue = 0;
< 
<         // Loop through arguments
<         $aArgs = Functions::flattenArray($args);
< 
<         $x = array_shift($aArgs);
<         $n = array_shift($aArgs);
<         $m = array_shift($aArgs);
< 
<         if ((is_numeric($x)) && (is_numeric($n)) && (is_numeric($m))) {
<             // Calculate
<             $i = 0;
<             foreach ($aArgs as $arg) {
<                 // Is it a numeric value?
<                 if ((is_numeric($arg)) && (!is_string($arg))) {
<                     $returnValue += $arg * $x ** ($n + ($m * $i++));
<                 } else {
<                     return Functions::VALUE();
<                 }
<             }
< 
<             return $returnValue;
<         }
< 
<         return Functions::VALUE();



>         return MathTrig\SeriesSum::evaluate($x, $n, $m, ...$args);


    }

    /**
     * SIGN.
     *
     * Determines the sign of a number. Returns 1 if the number is positive, zero (0)
     *        if the number is 0, and -1 if the number is negative.
     *

<      * @param float $number Number to round



>      * @deprecated 1.18.0
>      *      Use the evaluate method in the MathTrig\Sign class instead
>      * @see MathTrig\Sign::evaluate()
>      *
>      * @param array|float $number Number to round


     *

<      * @return int|string sign value, or a string containing an error



>      * @return array|int|string sign value, or a string containing an error


     */
    public static function SIGN($number)
    {

<         $number = Functions::flattenSingleValue($number);
< 
<         if (is_bool($number)) {
<             return (int) $number;
<         }
<         if (is_numeric($number)) {
<             if ($number == 0.0) {
<                 return 0;
<             }
< 
<             return $number / abs($number);



>         return MathTrig\Sign::evaluate($number);


        }


<         return Functions::VALUE();



>     /**
>      * returnSign = returns 0/-1/+1.
>      *
>      * @deprecated 1.18.0
>      *      Use the returnSign method in the MathTrig\Helpers class instead
>      * @see MathTrig\Helpers::returnSign()
>      */
>     public static function returnSign(float $number): int
>     {
>         return MathTrig\Helpers::returnSign($number);


    }

    /**
     * SQRTPI.
     *
     * Returns the square root of (number * pi).
     *

<      * @param float $number Number



>      * @deprecated 1.18.0
>      *      Use the pi method in the MathTrig\Sqrt class instead
>      * @see MathTrig\Sqrt::sqrt()
>      *
>      * @param array|float $number Number


     *

<      * @return float|string Square Root of Number * Pi, or a string containing an error



>      * @return array|float|string Square Root of Number * Pi, or a string containing an error


     */
    public static function SQRTPI($number)
    {

<         $number = Functions::flattenSingleValue($number);
< 
<         if (is_numeric($number)) {
<             if ($number < 0) {
<                 return Functions::NAN();
<             }
< 
<             return sqrt($number * M_PI);
<         }
< 
<         return Functions::VALUE();
<     }
< 
<     protected static function filterHiddenArgs($cellReference, $args)
<     {
<         return array_filter(
<             $args,
<             function ($index) use ($cellReference) {
<                 [, $row, $column] = explode('.', $index);
< 
<                 return $cellReference->getWorksheet()->getRowDimension($row)->getVisible() &&
<                     $cellReference->getWorksheet()->getColumnDimension($column)->getVisible();
<             },
<             ARRAY_FILTER_USE_KEY
<         );
<     }
< 
<     protected static function filterFormulaArgs($cellReference, $args)
<     {
<         return array_filter(
<             $args,
<             function ($index) use ($cellReference) {
<                 [, $row, $column] = explode('.', $index);
<                 if ($cellReference->getWorksheet()->cellExists($column . $row)) {
<                     //take this cell out if it contains the SUBTOTAL or AGGREGATE functions in a formula
<                     $isFormula = $cellReference->getWorksheet()->getCell($column . $row)->isFormula();
<                     $cellFormula = !preg_match('/^=.*\b(SUBTOTAL|AGGREGATE)\s*\(/i', $cellReference->getWorksheet()->getCell($column . $row)->getValue());
< 
<                     return !$isFormula || $cellFormula;
<                 }
< 
<                 return true;
<             },
<             ARRAY_FILTER_USE_KEY
<         );



>         return MathTrig\Sqrt::pi($number);


    }

    /**
     * SUBTOTAL.
     *
     * Returns a subtotal in a list or database.
     *

>      * @deprecated 1.18.0
     * @param int $functionType
>      *      Use the evaluate method in the MathTrig\Subtotal class instead
     *            A number 1 to 11 that specifies which function to
>      * @see MathTrig\Subtotal::evaluate()
     *                    use in calculating subtotals within a range
>      *


     *                    list
     *            Numbers 101 to 111 shadow the functions of 1 to 11
     *                    but ignore any values in the range that are
     *                    in hidden rows or columns
     * @param mixed[] $args A mixed data series of values
     *
     * @return float|string
     */
    public static function SUBTOTAL($functionType, ...$args)
    {

<         $cellReference = array_pop($args);
<         $aArgs = Functions::flattenArrayIndexed($args);
<         $subtotal = Functions::flattenSingleValue($functionType);
< 
<         // Calculate
<         if ((is_numeric($subtotal)) && (!is_string($subtotal))) {
<             if ($subtotal > 100) {
<                 $aArgs = self::filterHiddenArgs($cellReference, $aArgs);
<                 $subtotal -= 100;
<             }
< 
<             $aArgs = self::filterFormulaArgs($cellReference, $aArgs);
<             switch ($subtotal) {
<                 case 1:
<                     return Statistical::AVERAGE($aArgs);
<                 case 2:
<                     return Statistical::COUNT($aArgs);
<                 case 3:
<                     return Statistical::COUNTA($aArgs);
<                 case 4:
<                     return Statistical::MAX($aArgs);
<                 case 5:
<                     return Statistical::MIN($aArgs);
<                 case 6:
<                     return self::PRODUCT($aArgs);
<                 case 7:
<                     return Statistical::STDEV($aArgs);
<                 case 8:
<                     return Statistical::STDEVP($aArgs);
<                 case 9:
<                     return self::SUM($aArgs);
<                 case 10:
<                     return Statistical::VARFunc($aArgs);
<                 case 11:
<                     return Statistical::VARP($aArgs);
<             }
<         }
< 
<         return Functions::VALUE();



>         return MathTrig\Subtotal::evaluate($functionType, ...$args);


    }

    /**
     * SUM.
     *
     * SUM computes the sum of all the values and cells referenced in the argument list.
     *

>      * @deprecated 1.18.0
     * Excel Function:
>      *      Use the sumErroringStrings method in the MathTrig\Sum class instead
     *        SUM(value1[,value2[, ...]])
>      * @see MathTrig\Sum::sumErroringStrings()
     *
>      *


     * @param mixed ...$args Data values
     *

<      * @return float



>      * @return float|string


     */
    public static function SUM(...$args)
    {

<         $returnValue = 0;
< 
<         // Loop through the arguments
<         foreach (Functions::flattenArray($args) as $arg) {
<             // Is it a numeric value?
<             if ((is_numeric($arg)) && (!is_string($arg))) {
<                 $returnValue += $arg;
<             } elseif (Functions::isError($arg)) {
<                 return $arg;
<             }
<         }
< 
<         return $returnValue;



>         return MathTrig\Sum::sumIgnoringStrings(...$args);


    }

    /**
     * SUMIF.
     *

<      * Counts the number of cells that contain numbers within the list of arguments



>      * Totals the values of cells that contain numbers within the list of arguments


     *
     * Excel Function:

<      *        SUMIF(value1[,value2[, ...]],condition)



>      *        SUMIF(range, criteria, [sum_range])


     *

<      * @param mixed $aArgs Data values
<      * @param string $condition the criteria that defines which cells will be summed
<      * @param mixed $sumArgs



>      * @deprecated 1.17.0
>      *      Use the SUMIF() method in the Statistical\Conditional class instead
>      * @see Statistical\Conditional::SUMIF()


     *

<      * @return float



>      * @param mixed $range Data values
>      * @param string $criteria the criteria that defines which cells will be summed
>      * @param mixed $sumRange
>      *
>      * @return null|float|string


     */

<     public static function SUMIF($aArgs, $condition, $sumArgs = [])



>     public static function SUMIF($range, $criteria, $sumRange = [])


    {

<         $returnValue = 0;
< 
<         $aArgs = Functions::flattenArray($aArgs);
<         $sumArgs = Functions::flattenArray($sumArgs);
<         if (empty($sumArgs)) {
<             $sumArgs = $aArgs;
<         }
<         $condition = Functions::ifCondition($condition);
<         // Loop through arguments
<         foreach ($aArgs as $key => $arg) {
<             if (!is_numeric($arg)) {
<                 $arg = str_replace('"', '""', $arg);
<                 $arg = Calculation::wrapResult(strtoupper($arg));
<             }
< 
<             $testCondition = '=' . $arg . $condition;
<             $sumValue = array_key_exists($key, $sumArgs) ? $sumArgs[$key] : 0;
< 
<             if (
<                 is_numeric($sumValue) &&
<                 Calculation::getInstance()->_calculateFormulaValue($testCondition)
<             ) {
<                 // Is it a value within our criteria and only numeric can be added to the result
<                 $returnValue += $sumValue;
<             }
<         }
< 
<         return $returnValue;



>         return Statistical\Conditional::SUMIF($range, $criteria, $sumRange);


    }

    /**
     * SUMIFS.
     *

<      *    Counts the number of cells that contain numbers within the list of arguments



>      *    Totals the values of cells that contain numbers within the list of arguments


     *
     *    Excel Function:

<      *        SUMIFS(value1[,value2[, ...]],condition)



>      *        SUMIFS(sum_range, criteria_range1, criteria1, [criteria_range2, criteria2], ...)
>      *
>      * @deprecated 1.17.0
>      *      Use the SUMIFS() method in the Statistical\Conditional class instead
>      * @see Statistical\Conditional::SUMIFS()


     *
     * @param mixed $args Data values
     *

<      * @return float



>      * @return null|float|string


     */
    public static function SUMIFS(...$args)
    {

<         $arrayList = $args;
< 
<         // Return value
<         $returnValue = 0;
< 
<         $sumArgs = Functions::flattenArray(array_shift($arrayList));
<         $aArgsArray = [];
<         $conditions = [];
< 
<         while (count($arrayList) > 0) {
<             $aArgsArray[] = Functions::flattenArray(array_shift($arrayList));
<             $conditions[] = Functions::ifCondition(array_shift($arrayList));
<         }
< 
<         // Loop through each sum and see if arguments and conditions are true
<         foreach ($sumArgs as $index => $value) {
<             $valid = true;
< 
<             foreach ($conditions as $cidx => $condition) {
<                 $arg = $aArgsArray[$cidx][$index];
< 
<                 // Loop through arguments
<                 if (!is_numeric($arg)) {
<                     $arg = Calculation::wrapResult(strtoupper($arg));
<                 }
<                 $testCondition = '=' . $arg . $condition;
<                 if (!Calculation::getInstance()->_calculateFormulaValue($testCondition)) {
<                     // Is not a value within our criteria
<                     $valid = false;
< 
<                     break; // if false found, don't need to check other conditions
<                 }
<             }
< 
<             if ($valid) {
<                 $returnValue += $value;
<             }
<         }
< 
<         // Return
<         return $returnValue;



>         return Statistical\Conditional::SUMIFS(...$args);


    }

    /**
     * SUMPRODUCT.
     *
     * Excel Function:
     *        SUMPRODUCT(value1[,value2[, ...]])
     *

>      * @deprecated 1.18.0
     * @param mixed ...$args Data values
>      *      Use the product method in the MathTrig\Sum class instead
     *
>      * @see MathTrig\Sum::product()
     * @return float|string The result, or a string containing an error
>      *


     */
    public static function SUMPRODUCT(...$args)
    {

<         $arrayList = $args;
< 
<         $wrkArray = Functions::flattenArray(array_shift($arrayList));
<         $wrkCellCount = count($wrkArray);
< 
<         for ($i = 0; $i < $wrkCellCount; ++$i) {
<             if ((!is_numeric($wrkArray[$i])) || (is_string($wrkArray[$i]))) {
<                 $wrkArray[$i] = 0;
<             }
<         }
< 
<         foreach ($arrayList as $matrixData) {
<             $array2 = Functions::flattenArray($matrixData);
<             $count = count($array2);
<             if ($wrkCellCount != $count) {
<                 return Functions::VALUE();
<             }
< 
<             foreach ($array2 as $i => $val) {
<                 if ((!is_numeric($val)) || (is_string($val))) {
<                     $val = 0;
<                 }
<                 $wrkArray[$i] *= $val;
<             }
<         }
< 
<         return array_sum($wrkArray);



>         return MathTrig\Sum::product(...$args);


    }

    /**
     * SUMSQ.
     *
     * SUMSQ returns the sum of the squares of the arguments
     *

>      * @deprecated 1.18.0
     * Excel Function:
>      *      Use the sumSquare method in the MathTrig\SumSquares class instead
     *        SUMSQ(value1[,value2[, ...]])
>      * @see MathTrig\SumSquares::sumSquare()
     *
>      *


     * @param mixed ...$args Data values
     *

<      * @return float



>      * @return float|string


     */
    public static function SUMSQ(...$args)
    {

<         $returnValue = 0;
< 
<         // Loop through arguments
<         foreach (Functions::flattenArray($args) as $arg) {
<             // Is it a numeric value?
<             if ((is_numeric($arg)) && (!is_string($arg))) {
<                 $returnValue += ($arg * $arg);
<             }
<         }
< 
<         return $returnValue;



>         return MathTrig\SumSquares::sumSquare(...$args);


    }

    /**
     * SUMX2MY2.
     *

>      * @deprecated 1.18.0
     * @param mixed[] $matrixData1 Matrix #1
>      *     Use the sumXSquaredMinusYSquared method in the MathTrig\SumSquares class instead
     * @param mixed[] $matrixData2 Matrix #2
>      * @see MathTrig\SumSquares::sumXSquaredMinusYSquared()
     *
>      *



<      * @return float



>      * @return float|string


     */
    public static function SUMX2MY2($matrixData1, $matrixData2)
    {

<         $array1 = Functions::flattenArray($matrixData1);
<         $array2 = Functions::flattenArray($matrixData2);
<         $count = min(count($array1), count($array2));
< 
<         $result = 0;
<         for ($i = 0; $i < $count; ++$i) {
<             if (
<                 ((is_numeric($array1[$i])) && (!is_string($array1[$i]))) &&
<                 ((is_numeric($array2[$i])) && (!is_string($array2[$i])))
<             ) {
<                 $result += ($array1[$i] * $array1[$i]) - ($array2[$i] * $array2[$i]);
<             }
<         }
< 
<         return $result;



>         return MathTrig\SumSquares::sumXSquaredMinusYSquared($matrixData1, $matrixData2);


    }

    /**
     * SUMX2PY2.
     *

>      * @deprecated 1.18.0
     * @param mixed[] $matrixData1 Matrix #1
>      *     Use the sumXSquaredPlusYSquared method in the MathTrig\SumSquares class instead
     * @param mixed[] $matrixData2 Matrix #2
>      * @see MathTrig\SumSquares::sumXSquaredPlusYSquared()
     *
>      *



<      * @return float



>      * @return float|string


     */
    public static function SUMX2PY2($matrixData1, $matrixData2)
    {

<         $array1 = Functions::flattenArray($matrixData1);
<         $array2 = Functions::flattenArray($matrixData2);
<         $count = min(count($array1), count($array2));
< 
<         $result = 0;
<         for ($i = 0; $i < $count; ++$i) {
<             if (
<                 ((is_numeric($array1[$i])) && (!is_string($array1[$i]))) &&
<                 ((is_numeric($array2[$i])) && (!is_string($array2[$i])))
<             ) {
<                 $result += ($array1[$i] * $array1[$i]) + ($array2[$i] * $array2[$i]);
<             }
<         }
< 
<         return $result;



>         return MathTrig\SumSquares::sumXSquaredPlusYSquared($matrixData1, $matrixData2);


    }

    /**
     * SUMXMY2.
     *

>      * @deprecated 1.18.0
     * @param mixed[] $matrixData1 Matrix #1
>      *      Use the sumXMinusYSquared method in the MathTrig\SumSquares class instead
     * @param mixed[] $matrixData2 Matrix #2
>      * @see MathTrig\SumSquares::sumXMinusYSquared()
     *
>      *



<      * @return float



>      * @return float|string


     */
    public static function SUMXMY2($matrixData1, $matrixData2)
    {

<         $array1 = Functions::flattenArray($matrixData1);
<         $array2 = Functions::flattenArray($matrixData2);
<         $count = min(count($array1), count($array2));
< 
<         $result = 0;
<         for ($i = 0; $i < $count; ++$i) {
<             if (
<                 ((is_numeric($array1[$i])) && (!is_string($array1[$i]))) &&
<                 ((is_numeric($array2[$i])) && (!is_string($array2[$i])))
<             ) {
<                 $result += ($array1[$i] - $array2[$i]) * ($array1[$i] - $array2[$i]);
<             }
<         }
< 
<         return $result;



>         return MathTrig\SumSquares::sumXMinusYSquared($matrixData1, $matrixData2);


    }

    /**
     * TRUNC.
     *
     * Truncates value to the number of fractional digits by number_digits.
     *

>      * @deprecated 1.17.0
     * @param float $value
>      *      Use the evaluate() method in the MathTrig\Trunc class instead
     * @param int $digits
>      * @see MathTrig\Trunc::evaluate()
     *
>      *



<      * @return float|string Truncated value, or a string containing an error



>      * @return array|float|string Truncated value, or a string containing an error


     */
    public static function TRUNC($value = 0, $digits = 0)
    {

<         $value = Functions::flattenSingleValue($value);
<         $digits = Functions::flattenSingleValue($digits);
< 
<         // Validate parameters
<         if ((!is_numeric($value)) || (!is_numeric($digits))) {
<             return Functions::VALUE();
<         }
<         $digits = floor($digits);
< 
<         // Truncate
<         $adjust = 10 ** $digits;
< 
<         if (($digits > 0) && (rtrim((int) ((abs($value) - abs((int) $value)) * $adjust), '0') < $adjust / 10)) {
<             return $value;
<         }
< 
<         return ((int) ($value * $adjust)) / $adjust;



>         return MathTrig\Trunc::evaluate($value, $digits);


    }

    /**
     * SEC.
     *
     * Returns the secant of an angle.
     *

<      * @param float $angle Number



>      * @deprecated 1.18.0
>      *      Use the sec method in the MathTrig\Trig\Secant class instead
>      * @see MathTrig\Trig\Secant::sec()
>      *
>      * @param array|float $angle Number


     *

<      * @return float|string The secant of the angle



>      * @return array|float|string The secant of the angle


     */
    public static function SEC($angle)
    {

<         $angle = Functions::flattenSingleValue($angle);
< 
<         if (!is_numeric($angle)) {
<             return Functions::VALUE();
<         }
< 
<         $result = cos($angle);
< 
<         return ($result == 0.0) ? Functions::DIV0() : 1 / $result;



>         return MathTrig\Trig\Secant::sec($angle);


    }

    /**
     * SECH.
     *
     * Returns the hyperbolic secant of an angle.
     *

<      * @param float $angle Number



>      * @deprecated 1.18.0
>      *      Use the sech method in the MathTrig\Trig\Secant class instead
>      * @see MathTrig\Trig\Secant::sech()
>      *
>      * @param array|float $angle Number


     *

<      * @return float|string The hyperbolic secant of the angle



>      * @return array|float|string The hyperbolic secant of the angle


     */
    public static function SECH($angle)
    {

<         $angle = Functions::flattenSingleValue($angle);



>         return MathTrig\Trig\Secant::sech($angle);
>     }




<         if (!is_numeric($angle)) {
<             return Functions::VALUE();



>     /**
>      * CSC.
>      *
>      * Returns the cosecant of an angle.
>      *
>      * @deprecated 1.18.0
>      *      Use the csc method in the MathTrig\Trig\Cosecant class instead
>      * @see MathTrig\Trig\Cosecant::csc()
>      *
>      * @param array|float $angle Number
>      *
>      * @return array|float|string The cosecant of the angle
>      */
>     public static function CSC($angle)
>     {
>         return MathTrig\Trig\Cosecant::csc($angle);


        }


<         $result = cosh($angle);



>     /**
>      * CSCH.
>      *
>      * Returns the hyperbolic cosecant of an angle.
>      *
>      * @deprecated 1.18.0
>      *      Use the csch method in the MathTrig\Trig\Cosecant class instead
>      * @see MathTrig\Trig\Cosecant::csch()
>      *
>      * @param array|float $angle Number
>      *
>      * @return array|float|string The hyperbolic cosecant of the angle
>      */
>     public static function CSCH($angle)
>     {
>         return MathTrig\Trig\Cosecant::csch($angle);
>     }




<         return ($result == 0.0) ? Functions::DIV0() : 1 / $result;



>     /**
>      * COT.
>      *
>      * Returns the cotangent of an angle.
>      *
>      * @deprecated 1.18.0
>      *      Use the cot method in the MathTrig\Trig\Cotangent class instead
>      * @see MathTrig\Trig\Cotangent::cot()
>      *
>      * @param array|float $angle Number
>      *
>      * @return array|float|string The cotangent of the angle
>      */
>     public static function COT($angle)
>     {
>         return MathTrig\Trig\Cotangent::cot($angle);


    }

    /**

<      * CSC.



>      * COTH.


     *

<      * Returns the cosecant of an angle.



>      * Returns the hyperbolic cotangent of an angle.
>      *
>      * @deprecated 1.18.0
>      *      Use the coth method in the MathTrig\Trig\Cotangent class instead
>      * @see MathTrig\Trig\Cotangent::coth()


     *

<      * @param float $angle Number



>      * @param array|float $angle Number


     *

<      * @return float|string The cosecant of the angle



>      * @return array|float|string The hyperbolic cotangent of the angle


     */

<     public static function CSC($angle)



>     public static function COTH($angle)
>     {
>         return MathTrig\Trig\Cotangent::coth($angle);
>     }
> 
>     /**
>      * ACOT.
>      *
>      * Returns the arccotangent of a number.
>      *
>      * @deprecated 1.18.0
>      *      Use the acot method in the MathTrig\Trig\Cotangent class instead
>      * @see MathTrig\Trig\Cotangent::acot()
>      *
>      * @param array|float $number Number
>      *
>      * @return array|float|string The arccotangent of the number
>      */
>     public static function ACOT($number)
>     {
>         return MathTrig\Trig\Cotangent::acot($number);
>     }
> 
>     /**
>      * Return NAN or value depending on argument.
>      *
>      * @deprecated 1.18.0
>      *      Use the numberOrNan method in the MathTrig\Helpers class instead
>      * @see MathTrig\Helpers::numberOrNan()
>      *
>      * @param float $result Number
>      *
>      * @return float|string
>      */
>     public static function numberOrNan($result)


    {

<         $angle = Functions::flattenSingleValue($angle);



>         return MathTrig\Helpers::numberOrNan($result);
>     }




<         if (!is_numeric($angle)) {
<             return Functions::VALUE();



>     /**
>      * ACOTH.
>      *
>      * Returns the hyperbolic arccotangent of a number.
>      *
>      * @deprecated 1.18.0
>      *      Use the acoth method in the MathTrig\Trig\Cotangent class instead
>      * @see MathTrig\Trig\Cotangent::acoth()
>      *
>      * @param array|float $number Number
>      *
>      * @return array|float|string The hyperbolic arccotangent of the number
>      */
>     public static function ACOTH($number)
>     {
>         return MathTrig\Trig\Cotangent::acoth($number);


        }


<         $result = sin($angle);



>     /**
>      * ROUND.
>      *
>      * Returns the result of builtin function round after validating args.
>      *
>      * @deprecated 1.17.0
>      *      Use the round() method in the MathTrig\Round class instead
>      * @see MathTrig\Round::round()
>      *
>      * @param array|mixed $number Should be numeric
>      * @param array|mixed $precision Should be int
>      *
>      * @return array|float|string Rounded number
>      */
>     public static function builtinROUND($number, $precision)
>     {
>         return MathTrig\Round::round($number, $precision);
>     }




<         return ($result == 0.0) ? Functions::DIV0() : 1 / $result;



>     /**
>      * ABS.
>      *
>      * Returns the result of builtin function abs after validating args.
>      *
>      * @deprecated 1.18.0
>      *      Use the evaluate method in the MathTrig\Absolute class instead
>      * @see MathTrig\Absolute::evaluate()
>      *
>      * @param array|mixed $number Should be numeric
>      *
>      * @return array|float|int|string Rounded number
>      */
>     public static function builtinABS($number)
>     {
>         return MathTrig\Absolute::evaluate($number);


    }

    /**

<      * CSCH.



>      * ACOS.


     *

<      * Returns the hyperbolic cosecant of an angle.



>      * @deprecated 1.18.0
>      *      Use the acos method in the MathTrig\Trig\Cosine class instead
>      * @see MathTrig\Trig\Cosine::acos()
>      *
>      * Returns the result of builtin function acos after validating args.


     *

<      * @param float $angle Number



>      * @param array|float $number Should be numeric


     *

<      * @return float|string The hyperbolic cosecant of the angle



>      * @return array|float|string Rounded number


     */

<     public static function CSCH($angle)



>     public static function builtinACOS($number)


    {

<         $angle = Functions::flattenSingleValue($angle);



>         return MathTrig\Trig\Cosine::acos($number);
>     }




<         if (!is_numeric($angle)) {
<             return Functions::VALUE();



>     /**
>      * ACOSH.
>      *
>      * Returns the result of builtin function acosh after validating args.
>      *
>      * @deprecated 1.18.0
>      *      Use the acosh method in the MathTrig\Trig\Cosine class instead
>      * @see MathTrig\Trig\Cosine::acosh()
>      *
>      * @param array|float $number Should be numeric
>      *
>      * @return array|float|string Rounded number
>      */
>     public static function builtinACOSH($number)
>     {
>         return MathTrig\Trig\Cosine::acosh($number);


        }


<         $result = sinh($angle);



>     /**
>      * ASIN.
>      *
>      * Returns the result of builtin function asin after validating args.
>      *
>      * @deprecated 1.18.0
>      *      Use the asin method in the MathTrig\Trig\Sine class instead
>      * @see MathTrig\Trig\Sine::asin()
>      *
>      * @param array|float $number Should be numeric
>      *
>      * @return array|float|string Rounded number
>      */
>     public static function builtinASIN($number)
>     {
>         return MathTrig\Trig\Sine::asin($number);
>     }




<         return ($result == 0.0) ? Functions::DIV0() : 1 / $result;



>     /**
>      * ASINH.
>      *
>      * Returns the result of builtin function asinh after validating args.
>      *
>      * @deprecated 1.18.0
>      *      Use the asinh method in the MathTrig\Trig\Sine class instead
>      * @see MathTrig\Trig\Sine::asinh()
>      *
>      * @param array|float $number Should be numeric
>      *
>      * @return array|float|string Rounded number
>      */
>     public static function builtinASINH($number)
>     {
>         return MathTrig\Trig\Sine::asinh($number);


    }

    /**

<      * COT.



>      * ATAN.


     *

<      * Returns the cotangent of an angle.



>      * Returns the result of builtin function atan after validating args.


     *

<      * @param float $angle Number



>      * @deprecated 1.18.0
>      *      Use the atan method in the MathTrig\Trig\Tangent class instead
>      * @see MathTrig\Trig\Tangent::atan()


     *

<      * @return float|string The cotangent of the angle



>      * @param array|float $number Should be numeric
>      *
>      * @return array|float|string Rounded number


     */

<     public static function COT($angle)



>     public static function builtinATAN($number)


    {

<         $angle = Functions::flattenSingleValue($angle);



>         return MathTrig\Trig\Tangent::atan($number);
>     }




<         if (!is_numeric($angle)) {
<             return Functions::VALUE();



>     /**
>      * ATANH.
>      *
>      * Returns the result of builtin function atanh after validating args.
>      *
>      * @deprecated 1.18.0
>      *      Use the atanh method in the MathTrig\Trig\Tangent class instead
>      * @see MathTrig\Trig\Tangent::atanh()
>      *
>      * @param array|float $number Should be numeric
>      *
>      * @return array|float|string Rounded number
>      */
>     public static function builtinATANH($number)
>     {
>         return MathTrig\Trig\Tangent::atanh($number);


        }


<         $result = tan($angle);



>     /**
>      * COS.
>      *
>      * Returns the result of builtin function cos after validating args.
>      *
>      * @deprecated 1.18.0
>      *      Use the cos method in the MathTrig\Trig\Cosine class instead
>      * @see MathTrig\Trig\Cosine::cos()
>      *
>      * @param array|mixed $number Should be numeric
>      *
>      * @return array|float|string Rounded number
>      */
>     public static function builtinCOS($number)
>     {
>         return MathTrig\Trig\Cosine::cos($number);
>     }




<         return ($result == 0.0) ? Functions::DIV0() : 1 / $result;



>     /**
>      * COSH.
>      *
>      * Returns the result of builtin function cos after validating args.
>      *
>      * @deprecated 1.18.0
>      *      Use the cosh method in the MathTrig\Trig\Cosine class instead
>      * @see MathTrig\Trig\Cosine::cosh()
>      *
>      * @param array|mixed $number Should be numeric
>      *
>      * @return array|float|string Rounded number
>      */
>     public static function builtinCOSH($number)
>     {
>         return MathTrig\Trig\Cosine::cosh($number);


    }

    /**

<      * COTH.



>      * DEGREES.


     *

<      * Returns the hyperbolic cotangent of an angle.



>      * Returns the result of builtin function rad2deg after validating args.
>      *
>      * @deprecated 1.18.0
>      *      Use the toDegrees method in the MathTrig\Angle class instead
>      * @see MathTrig\Angle::toDegrees()


     *

<      * @param float $angle Number



>      * @param array|mixed $number Should be numeric


     *

<      * @return float|string The hyperbolic cotangent of the angle



>      * @return array|float|string Rounded number


     */

<     public static function COTH($angle)



>     public static function builtinDEGREES($number)


    {

<         $angle = Functions::flattenSingleValue($angle);



>         return MathTrig\Angle::toDegrees($number);
>     }




<         if (!is_numeric($angle)) {
<             return Functions::VALUE();



>     /**
>      * EXP.
>      *
>      * Returns the result of builtin function exp after validating args.
>      *
>      * @deprecated 1.18.0
>      *      Use the evaluate method in the MathTrig\Exp class instead
>      * @see MathTrig\Exp::evaluate()
>      *
>      * @param array|mixed $number Should be numeric
>      *
>      * @return array|float|string Rounded number
>      */
>     public static function builtinEXP($number)
>     {
>         return MathTrig\Exp::evaluate($number);


        }


<         $result = tanh($angle);



>     /**
>      * LN.
>      *
>      * Returns the result of builtin function log after validating args.
>      *
>      * @deprecated 1.18.0
>      *      Use the natural method in the MathTrig\Logarithms class instead
>      * @see MathTrig\Logarithms::natural()
>      *
>      * @param mixed $number Should be numeric
>      *
>      * @return array|float|string Rounded number
>      */
>     public static function builtinLN($number)
>     {
>         return MathTrig\Logarithms::natural($number);
>     }




<         return ($result == 0.0) ? Functions::DIV0() : 1 / $result;



>     /**
>      * LOG10.
>      *
>      * Returns the result of builtin function log after validating args.
>      *
>      * @deprecated 1.18.0
>      *      Use the natural method in the MathTrig\Logarithms class instead
>      * @see MathTrig\Logarithms::base10()
>      *
>      * @param mixed $number Should be numeric
>      *
>      * @return array|float|string Rounded number
>      */
>     public static function builtinLOG10($number)
>     {
>         return MathTrig\Logarithms::base10($number);


    }

    /**

<      * ACOT.



>      * RADIANS.


     *

<      * Returns the arccotangent of a number.



>      * Returns the result of builtin function deg2rad after validating args.
>      *
>      * @deprecated 1.18.0
>      *      Use the toRadians method in the MathTrig\Angle class instead
>      * @see MathTrig\Angle::toRadians()


     *

<      * @param float $number Number



>      * @param array|mixed $number Should be numeric


     *

<      * @return float|string The arccotangent of the number



>      * @return array|float|string Rounded number


     */

<     public static function ACOT($number)



>     public static function builtinRADIANS($number)


    {

<         $number = Functions::flattenSingleValue($number);



>         return MathTrig\Angle::toRadians($number);
>     }




<         if (!is_numeric($number)) {
<             return Functions::VALUE();



>     /**
>      * SIN.
>      *
>      * Returns the result of builtin function sin after validating args.
>      *
>      * @deprecated 1.18.0
>      *      Use the sin method in the MathTrig\Trig\Sine class instead
>      * @see MathTrig\Trig\Sine::evaluate()
>      *
>      * @param array|mixed $number Should be numeric
>      *
>      * @return array|float|string sine
>      */
>     public static function builtinSIN($number)
>     {
>         return MathTrig\Trig\Sine::sin($number);


        }


<         return (M_PI / 2) - atan($number);



>     /**
>      * SINH.
>      *
>      * Returns the result of builtin function sinh after validating args.
>      *
>      * @deprecated 1.18.0
>      *      Use the sinh method in the MathTrig\Trig\Sine class instead
>      * @see MathTrig\Trig\Sine::sinh()
>      *
>      * @param array|mixed $number Should be numeric
>      *
>      * @return array|float|string Rounded number
>      */
>     public static function builtinSINH($number)
>     {
>         return MathTrig\Trig\Sine::sinh($number);


    }

    /**

<      * ACOTH.



>      * SQRT.


     *

<      * Returns the hyperbolic arccotangent of a number.



>      * Returns the result of builtin function sqrt after validating args.
>      *
>      * @deprecated 1.18.0
>      *      Use the sqrt method in the MathTrig\Sqrt class instead
>      * @see MathTrig\Sqrt::sqrt()


     *

<      * @param float $number Number



>      * @param array|mixed $number Should be numeric


     *

<      * @return float|string The hyperbolic arccotangent of the number



>      * @return array|float|string Rounded number


     */

<     public static function ACOTH($number)



>     public static function builtinSQRT($number)


    {

<         $number = Functions::flattenSingleValue($number);



>         return MathTrig\Sqrt::sqrt($number);
>     }




<         if (!is_numeric($number)) {
<             return Functions::VALUE();



>     /**
>      * TAN.
>      *
>      * Returns the result of builtin function tan after validating args.
>      *
>      * @deprecated 1.18.0
>      *      Use the tan method in the MathTrig\Trig\Tangent class instead
>      * @see MathTrig\Trig\Tangent::tan()
>      *
>      * @param array|mixed $number Should be numeric
>      *
>      * @return array|float|string Rounded number
>      */
>     public static function builtinTAN($number)
>     {
>         return MathTrig\Trig\Tangent::tan($number);


        }


<         $result = log(($number + 1) / ($number - 1)) / 2;



>     /**
>      * TANH.
>      *
>      * Returns the result of builtin function sinh after validating args.
>      *
>      * @deprecated 1.18.0
>      *      Use the tanh method in the MathTrig\Trig\Tangent class instead
>      * @see MathTrig\Trig\Tangent::tanh()
>      *
>      * @param array|mixed $number Should be numeric
>      *
>      * @return array|float|string Rounded number
>      */
>     public static function builtinTANH($number)
>     {
>         return MathTrig\Trig\Tangent::tanh($number);
>     }




<         return is_nan($result) ? Functions::NAN() : $result;



>     /**
>      * Many functions accept null/false/true argument treated as 0/0/1.
>      *
>      * @deprecated 1.18.0
>      *      Use the validateNumericNullBool method in the MathTrig\Helpers class instead
>      * @see MathTrig\Helpers::validateNumericNullBool()
>      *
>      * @param mixed $number
>      */
>     public static function nullFalseTrueToNumber(&$number): void
>     {
>         $number = Functions::flattenSingleValue($number);
>         if ($number === null) {
>             $number = 0;
>         } elseif (is_bool($number)) {
>             $number = (int) $number;
>         }


    }
}