MathTrig.php

Go to the documentation of this file.

<?php

namespace PhpOffice\PhpSpreadsheet\Calculation;

class MathTrig
{
    public static function ARABIC($roman)
    {
        return MathTrig\Arabic::evaluate($roman);
    }

    public static function ATAN2($xCoordinate = null, $yCoordinate = null)
    {
        return MathTrig\Trig\Tangent::atan2($xCoordinate, $yCoordinate);
    }

    public static function BASE($number, $radix, $minLength = null)
    {
        return MathTrig\Base::evaluate($number, $radix, $minLength);
    }

    public static function CEILING($number, $significance = null)
    {
        return MathTrig\Ceiling::ceiling($number, $significance);
    }

    public static function COMBIN($numObjs, $numInSet)
    {
        return MathTrig\Combinations::withoutRepetition($numObjs, $numInSet);
    }

    public static function EVEN($number)
    {
        return MathTrig\Round::even($number);
    }

    public static function getEven(float $number): int
    {
        return (int) MathTrig\Helpers::getEven($number);
    }

    public static function FACT($factVal)
    {
        return MathTrig\Factorial::fact($factVal);
    }

    public static function FACTDOUBLE($factVal)
    {
        return MathTrig\Factorial::factDouble($factVal);
    }

    public static function FLOOR($number, $significance = null)
    {
        return MathTrig\Floor::floor($number, $significance);
    }

    public static function FLOORMATH($number, $significance = null, $mode = 0)
    {
        return MathTrig\Floor::math($number, $significance, $mode);
    }

    public static function FLOORPRECISE($number, $significance = 1)
    {
        return MathTrig\Floor::precise($number, $significance);
    }

    public static function INT($number)
    {
        return MathTrig\IntClass::evaluate($number);
    }

    public static function GCD(...$args)
    {
        return MathTrig\Gcd::evaluate(...$args);
    }

    public static function LCM(...$args)
    {
        return MathTrig\Lcm::evaluate(...$args);
    }

    public static function logBase($number, $base = 10)
    {
        return MathTrig\Logarithms::withBase($number, $base);
    }

    public static function MDETERM($matrixValues)
    {
        return MathTrig\MatrixFunctions::determinant($matrixValues);
    }

    public static function MINVERSE($matrixValues)
    {
        return MathTrig\MatrixFunctions::inverse($matrixValues);
    }

    public static function MMULT($matrixData1, $matrixData2)
    {
        return MathTrig\MatrixFunctions::multiply($matrixData1, $matrixData2);
    }

    public static function MOD($a = 1, $b = 1)
    {
        return MathTrig\Operations::mod($a, $b);
    }

    public static function MROUND($number, $multiple)
    {
        return MathTrig\Round::multiple($number, $multiple);
    }

    public static function MULTINOMIAL(...$args)
    {
        return MathTrig\Factorial::multinomial(...$args);
    }

    public static function ODD($number)
    {
        return MathTrig\Round::odd($number);
    }

    public static function POWER($x = 0, $y = 2)
    {
        return MathTrig\Operations::power($x, $y);
    }

    public static function PRODUCT(...$args)
    {
        return MathTrig\Operations::product(...$args);
    }

    public static function QUOTIENT($numerator, $denominator)
    {
        return MathTrig\Operations::quotient($numerator, $denominator);
    }

    public static function RAND($min = 0, $max = 0)
    {
        return MathTrig\Random::randBetween($min, $max);
    }

    public static function ROMAN($aValue, $style = 0)
    {
        return MathTrig\Roman::evaluate($aValue, $style);
    }

    public static function ROUNDUP($number, $digits)
    {
        return MathTrig\Round::up($number, $digits);
    }

    public static function ROUNDDOWN($number, $digits)
    {
        return MathTrig\Round::down($number, $digits);
    }

    public static function SERIESSUM($x, $n, $m, ...$args)
    {
        return MathTrig\SeriesSum::evaluate($x, $n, $m, ...$args);
    }

    public static function SIGN($number)
    {
        return MathTrig\Sign::evaluate($number);
    }

    public static function returnSign(float $number): int
    {
        return MathTrig\Helpers::returnSign($number);
    }

    public static function SQRTPI($number)
    {
        return MathTrig\Sqrt::pi($number);
    }

    public static function SUBTOTAL($functionType, ...$args)
    {
        return MathTrig\Subtotal::evaluate($functionType, ...$args);
    }

    public static function SUM(...$args)
    {
        return MathTrig\Sum::sumIgnoringStrings(...$args);
    }

    public static function SUMIF($range, $criteria, $sumRange = [])
    {
        return Statistical\Conditional::SUMIF($range, $criteria, $sumRange);
    }

    public static function SUMIFS(...$args)
    {
        return Statistical\Conditional::SUMIFS(...$args);
    }

    public static function SUMPRODUCT(...$args)
    {
        return MathTrig\Sum::product(...$args);
    }

    public static function SUMSQ(...$args)
    {
        return MathTrig\SumSquares::sumSquare(...$args);
    }

    public static function SUMX2MY2($matrixData1, $matrixData2)
    {
        return MathTrig\SumSquares::sumXSquaredMinusYSquared($matrixData1, $matrixData2);
    }

    public static function SUMX2PY2($matrixData1, $matrixData2)
    {
        return MathTrig\SumSquares::sumXSquaredPlusYSquared($matrixData1, $matrixData2);
    }

    public static function SUMXMY2($matrixData1, $matrixData2)
    {
        return MathTrig\SumSquares::sumXMinusYSquared($matrixData1, $matrixData2);
    }

    public static function TRUNC($value = 0, $digits = 0)
    {
        return MathTrig\Trunc::evaluate($value, $digits);
    }

    public static function SEC($angle)
    {
        return MathTrig\Trig\Secant::sec($angle);
    }

    public static function SECH($angle)
    {
        return MathTrig\Trig\Secant::sech($angle);
    }

    public static function CSC($angle)
    {
        return MathTrig\Trig\Cosecant::csc($angle);
    }

    public static function CSCH($angle)
    {
        return MathTrig\Trig\Cosecant::csch($angle);
    }

    public static function COT($angle)
    {
        return MathTrig\Trig\Cotangent::cot($angle);
    }

    public static function COTH($angle)
    {
        return MathTrig\Trig\Cotangent::coth($angle);
    }

    public static function ACOT($number)
    {
        return MathTrig\Trig\Cotangent::acot($number);
    }

    public static function numberOrNan($result)
    {
        return MathTrig\Helpers::numberOrNan($result);
    }

    public static function ACOTH($number)
    {
        return MathTrig\Trig\Cotangent::acoth($number);
    }

    public static function builtinROUND($number, $precision)
    {
        return MathTrig\Round::round($number, $precision);
    }

    public static function builtinABS($number)
    {
        return MathTrig\Absolute::evaluate($number);
    }

    public static function builtinACOS($number)
    {
        return MathTrig\Trig\Cosine::acos($number);
    }

    public static function builtinACOSH($number)
    {
        return MathTrig\Trig\Cosine::acosh($number);
    }

    public static function builtinASIN($number)
    {
        return MathTrig\Trig\Sine::asin($number);
    }

    public static function builtinASINH($number)
    {
        return MathTrig\Trig\Sine::asinh($number);
    }

    public static function builtinATAN($number)
    {
        return MathTrig\Trig\Tangent::atan($number);
    }

    public static function builtinATANH($number)
    {
        return MathTrig\Trig\Tangent::atanh($number);
    }

    public static function builtinCOS($number)
    {
        return MathTrig\Trig\Cosine::cos($number);
    }

    public static function builtinCOSH($number)
    {
        return MathTrig\Trig\Cosine::cosh($number);
    }

    public static function builtinDEGREES($number)
    {
        return MathTrig\Angle::toDegrees($number);
    }

    public static function builtinEXP($number)
    {
        return MathTrig\Exp::evaluate($number);
    }

    public static function builtinLN($number)
    {
        return MathTrig\Logarithms::natural($number);
    }

    public static function builtinLOG10($number)
    {
        return MathTrig\Logarithms::base10($number);
    }

    public static function builtinRADIANS($number)
    {
        return MathTrig\Angle::toRadians($number);
    }

    public static function builtinSIN($number)
    {
        return MathTrig\Trig\Sine::sin($number);
    }

    public static function builtinSINH($number)
    {
        return MathTrig\Trig\Sine::sinh($number);
    }

    public static function builtinSQRT($number)
    {
        return MathTrig\Sqrt::sqrt($number);
    }

    public static function builtinTAN($number)
    {
        return MathTrig\Trig\Tangent::tan($number);
    }

    public static function builtinTANH($number)
    {
        return MathTrig\Trig\Tangent::tanh($number);
    }

    public static function nullFalseTrueToNumber(&$number): void
    {
        $number = Functions::flattenSingleValue($number);
        if ($number === null) {
            $number = 0;
        } elseif (is_bool($number)) {
            $number = (int) $number;
        }
    }
}