Engineering.php

Go to the documentation of this file.

<?php
 
namespace PhpOffice\PhpSpreadsheet\Calculation;
 
use Complex\Complex;
use PhpOffice\PhpSpreadsheet\Calculation\Engineering\ComplexFunctions;
use PhpOffice\PhpSpreadsheet\Calculation\Engineering\ComplexOperations;
 
class Engineering
{
    public const EULER = 2.71828182845904523536;
 
    public static function parseComplex($complexNumber)
    {
        $complex = new Complex($complexNumber);
 
        return [
            'real' => $complex->getReal(),
            'imaginary' => $complex->getImaginary(),
            'suffix' => $complex->getSuffix(),
        ];
    }
 
    public static function BESSELI($x, $ord)
    {
        return Engineering\BesselI::BESSELI($x, $ord);
    }
 
    public static function BESSELJ($x, $ord)
    {
        return Engineering\BesselJ::BESSELJ($x, $ord);
    }
 
    public static function BESSELK($x, $ord)
    {
        return Engineering\BesselK::BESSELK($x, $ord);
    }
 
    public static function BESSELY($x, $ord)
    {
        return Engineering\BesselY::BESSELY($x, $ord);
    }
 
    public static function BINTODEC($x)
    {
        return Engineering\ConvertBinary::toDecimal($x);
    }
 
    public static function BINTOHEX($x, $places = null)
    {
        return Engineering\ConvertBinary::toHex($x, $places);
    }
 
    public static function BINTOOCT($x, $places = null)
    {
        return Engineering\ConvertBinary::toOctal($x, $places);
    }
 
    public static function DECTOBIN($x, $places = null)
    {
        return Engineering\ConvertDecimal::toBinary($x, $places);
    }
 
    public static function DECTOHEX($x, $places = null)
    {
        return Engineering\ConvertDecimal::toHex($x, $places);
    }
 
    public static function DECTOOCT($x, $places = null)
    {
        return Engineering\ConvertDecimal::toOctal($x, $places);
    }
 
    public static function HEXTOBIN($x, $places = null)
    {
        return Engineering\ConvertHex::toBinary($x, $places);
    }
 
    public static function HEXTODEC($x)
    {
        return Engineering\ConvertHex::toDecimal($x);
    }
 
    public static function HEXTOOCT($x, $places = null)
    {
        return Engineering\ConvertHex::toOctal($x, $places);
    }
 
    public static function OCTTOBIN($x, $places = null)
    {
        return Engineering\ConvertOctal::toBinary($x, $places);
    }
 
    public static function OCTTODEC($x)
    {
        return Engineering\ConvertOctal::toDecimal($x);
    }
 
    public static function OCTTOHEX($x, $places = null)
    {
        return Engineering\ConvertOctal::toHex($x, $places);
    }
 
    public static function COMPLEX($realNumber = 0.0, $imaginary = 0.0, $suffix = 'i')
    {
        return Engineering\Complex::COMPLEX($realNumber, $imaginary, $suffix);
    }
 
    public static function IMAGINARY($complexNumber)
    {
        return Engineering\Complex::IMAGINARY($complexNumber);
    }
 
    public static function IMREAL($complexNumber)
    {
        return Engineering\Complex::IMREAL($complexNumber);
    }
 
    public static function IMABS($complexNumber)
    {
        return ComplexFunctions::IMABS($complexNumber);
    }
 
    public static function IMARGUMENT($complexNumber)
    {
        return ComplexFunctions::IMARGUMENT($complexNumber);
    }
 
    public static function IMCONJUGATE($complexNumber)
    {
        return ComplexFunctions::IMCONJUGATE($complexNumber);
    }
 
    public static function IMCOS($complexNumber)
    {
        return ComplexFunctions::IMCOS($complexNumber);
    }
 
    public static function IMCOSH($complexNumber)
    {
        return ComplexFunctions::IMCOSH($complexNumber);
    }
 
    public static function IMCOT($complexNumber)
    {
        return ComplexFunctions::IMCOT($complexNumber);
    }
 
    public static function IMCSC($complexNumber)
    {
        return ComplexFunctions::IMCSC($complexNumber);
    }
 
    public static function IMCSCH($complexNumber)
    {
        return ComplexFunctions::IMCSCH($complexNumber);
    }
 
    public static function IMSIN($complexNumber)
    {
        return ComplexFunctions::IMSIN($complexNumber);
    }
 
    public static function IMSINH($complexNumber)
    {
        return ComplexFunctions::IMSINH($complexNumber);
    }
 
    public static function IMSEC($complexNumber)
    {
        return ComplexFunctions::IMSEC($complexNumber);
    }
 
    public static function IMSECH($complexNumber)
    {
        return ComplexFunctions::IMSECH($complexNumber);
    }
 
    public static function IMTAN($complexNumber)
    {
        return ComplexFunctions::IMTAN($complexNumber);
    }
 
    public static function IMSQRT($complexNumber)
    {
        return ComplexFunctions::IMSQRT($complexNumber);
    }
 
    public static function IMLN($complexNumber)
    {
        return ComplexFunctions::IMLN($complexNumber);
    }
 
    public static function IMLOG10($complexNumber)
    {
        return ComplexFunctions::IMLOG10($complexNumber);
    }
 
    public static function IMLOG2($complexNumber)
    {
        return ComplexFunctions::IMLOG2($complexNumber);
    }
 
    public static function IMEXP($complexNumber)
    {
        return ComplexFunctions::IMEXP($complexNumber);
    }
 
    public static function IMPOWER($complexNumber, $realNumber)
    {
        return ComplexFunctions::IMPOWER($complexNumber, $realNumber);
    }
 
    public static function IMDIV($complexDividend, $complexDivisor)
    {
        return ComplexOperations::IMDIV($complexDividend, $complexDivisor);
    }
 
    public static function IMSUB($complexNumber1, $complexNumber2)
    {
        return ComplexOperations::IMSUB($complexNumber1, $complexNumber2);
    }
 
    public static function IMSUM(...$complexNumbers)
    {
        return ComplexOperations::IMSUM(...$complexNumbers);
    }
 
    public static function IMPRODUCT(...$complexNumbers)
    {
        return ComplexOperations::IMPRODUCT(...$complexNumbers);
    }
 
    public static function DELTA($a, $b = 0)
    {
        return Engineering\Compare::DELTA($a, $b);
    }
 
    public static function GESTEP($number, $step = 0)
    {
        return Engineering\Compare::GESTEP($number, $step);
    }
 
    public static function BITAND($number1, $number2)
    {
        return Engineering\BitWise::BITAND($number1, $number2);
    }
 
    public static function BITOR($number1, $number2)
    {
        return Engineering\BitWise::BITOR($number1, $number2);
    }
 
    public static function BITXOR($number1, $number2)
    {
        return Engineering\BitWise::BITXOR($number1, $number2);
    }
 
    public static function BITLSHIFT($number, $shiftAmount)
    {
        return Engineering\BitWise::BITLSHIFT($number, $shiftAmount);
    }
 
    public static function BITRSHIFT($number, $shiftAmount)
    {
        return Engineering\BitWise::BITRSHIFT($number, $shiftAmount);
    }
 
    public static function ERF($lower, $upper = null)
    {
        return Engineering\Erf::ERF($lower, $upper);
    }
 
    public static function ERFPRECISE($limit)
    {
        return Engineering\Erf::ERFPRECISE($limit);
    }
 
    public static function ERFC($x)
    {
        return Engineering\ErfC::ERFC($x);
    }
 
    public static function getConversionGroups()
    {
        return Engineering\ConvertUOM::getConversionCategories();
    }
 
    public static function getConversionGroupUnits($category = null)
    {
        return Engineering\ConvertUOM::getConversionCategoryUnits($category);
    }
 
    public static function getConversionGroupUnitDetails($category = null)
    {
        return Engineering\ConvertUOM::getConversionCategoryUnitDetails($category);
    }
 
    public static function getConversionMultipliers()
    {
        return Engineering\ConvertUOM::getConversionMultipliers();
    }
 
    public static function getBinaryConversionMultipliers()
    {
        return Engineering\ConvertUOM::getBinaryConversionMultipliers();
    }
 
    public static function CONVERTUOM($value, $fromUOM, $toUOM)
    {
        return Engineering\ConvertUOM::CONVERT($value, $fromUOM, $toUOM);
    }
}