612 lines
19 KiB
PHP
612 lines
19 KiB
PHP
<?php
|
|
|
|
namespace PhpOffice\PhpSpreadsheet\Calculation\Engineering;
|
|
|
|
use Complex\Complex as ComplexObject;
|
|
use Complex\Exception as ComplexException;
|
|
use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
|
|
use PhpOffice\PhpSpreadsheet\Calculation\Information\ExcelError;
|
|
|
|
class ComplexFunctions
|
|
{
|
|
use ArrayEnabled;
|
|
|
|
/**
|
|
* IMABS.
|
|
*
|
|
* Returns the absolute value (modulus) of a complex number in x + yi or x + yj text format.
|
|
*
|
|
* Excel Function:
|
|
* IMABS(complexNumber)
|
|
*
|
|
* @param array|string $complexNumber the complex number for which you want the absolute value
|
|
* Or can be an array of values
|
|
*
|
|
* @return array|float|string
|
|
* If an array of numbers is passed as an argument, then the returned result will also be an array
|
|
* with the same dimensions
|
|
*/
|
|
public static function IMABS($complexNumber)
|
|
{
|
|
if (is_array($complexNumber)) {
|
|
return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $complexNumber);
|
|
}
|
|
|
|
try {
|
|
$complex = new ComplexObject($complexNumber);
|
|
} catch (ComplexException $e) {
|
|
return ExcelError::NAN();
|
|
}
|
|
|
|
return $complex->abs();
|
|
}
|
|
|
|
/**
|
|
* IMARGUMENT.
|
|
*
|
|
* Returns the argument theta of a complex number, i.e. the angle in radians from the real
|
|
* axis to the representation of the number in polar coordinates.
|
|
*
|
|
* Excel Function:
|
|
* IMARGUMENT(complexNumber)
|
|
*
|
|
* @param array|string $complexNumber the complex number for which you want the argument theta
|
|
* Or can be an array of values
|
|
*
|
|
* @return array|float|string
|
|
* If an array of numbers is passed as an argument, then the returned result will also be an array
|
|
* with the same dimensions
|
|
*/
|
|
public static function IMARGUMENT($complexNumber)
|
|
{
|
|
if (is_array($complexNumber)) {
|
|
return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $complexNumber);
|
|
}
|
|
|
|
try {
|
|
$complex = new ComplexObject($complexNumber);
|
|
} catch (ComplexException $e) {
|
|
return ExcelError::NAN();
|
|
}
|
|
|
|
if ($complex->getReal() == 0.0 && $complex->getImaginary() == 0.0) {
|
|
return ExcelError::DIV0();
|
|
}
|
|
|
|
return $complex->argument();
|
|
}
|
|
|
|
/**
|
|
* IMCONJUGATE.
|
|
*
|
|
* Returns the complex conjugate of a complex number in x + yi or x + yj text format.
|
|
*
|
|
* Excel Function:
|
|
* IMCONJUGATE(complexNumber)
|
|
*
|
|
* @param array|string $complexNumber the complex number for which you want the conjugate
|
|
* Or can be an array of values
|
|
*
|
|
* @return array|string
|
|
* If an array of numbers is passed as an argument, then the returned result will also be an array
|
|
* with the same dimensions
|
|
*/
|
|
public static function IMCONJUGATE($complexNumber)
|
|
{
|
|
if (is_array($complexNumber)) {
|
|
return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $complexNumber);
|
|
}
|
|
|
|
try {
|
|
$complex = new ComplexObject($complexNumber);
|
|
} catch (ComplexException $e) {
|
|
return ExcelError::NAN();
|
|
}
|
|
|
|
return (string) $complex->conjugate();
|
|
}
|
|
|
|
/**
|
|
* IMCOS.
|
|
*
|
|
* Returns the cosine of a complex number in x + yi or x + yj text format.
|
|
*
|
|
* Excel Function:
|
|
* IMCOS(complexNumber)
|
|
*
|
|
* @param array|string $complexNumber the complex number for which you want the cosine
|
|
* Or can be an array of values
|
|
*
|
|
* @return array|float|string
|
|
* If an array of numbers is passed as an argument, then the returned result will also be an array
|
|
* with the same dimensions
|
|
*/
|
|
public static function IMCOS($complexNumber)
|
|
{
|
|
if (is_array($complexNumber)) {
|
|
return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $complexNumber);
|
|
}
|
|
|
|
try {
|
|
$complex = new ComplexObject($complexNumber);
|
|
} catch (ComplexException $e) {
|
|
return ExcelError::NAN();
|
|
}
|
|
|
|
return (string) $complex->cos();
|
|
}
|
|
|
|
/**
|
|
* IMCOSH.
|
|
*
|
|
* Returns the hyperbolic cosine of a complex number in x + yi or x + yj text format.
|
|
*
|
|
* Excel Function:
|
|
* IMCOSH(complexNumber)
|
|
*
|
|
* @param array|string $complexNumber the complex number for which you want the hyperbolic cosine
|
|
* Or can be an array of values
|
|
*
|
|
* @return array|float|string
|
|
* If an array of numbers is passed as an argument, then the returned result will also be an array
|
|
* with the same dimensions
|
|
*/
|
|
public static function IMCOSH($complexNumber)
|
|
{
|
|
if (is_array($complexNumber)) {
|
|
return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $complexNumber);
|
|
}
|
|
|
|
try {
|
|
$complex = new ComplexObject($complexNumber);
|
|
} catch (ComplexException $e) {
|
|
return ExcelError::NAN();
|
|
}
|
|
|
|
return (string) $complex->cosh();
|
|
}
|
|
|
|
/**
|
|
* IMCOT.
|
|
*
|
|
* Returns the cotangent of a complex number in x + yi or x + yj text format.
|
|
*
|
|
* Excel Function:
|
|
* IMCOT(complexNumber)
|
|
*
|
|
* @param array|string $complexNumber the complex number for which you want the cotangent
|
|
* Or can be an array of values
|
|
*
|
|
* @return array|float|string
|
|
* If an array of numbers is passed as an argument, then the returned result will also be an array
|
|
* with the same dimensions
|
|
*/
|
|
public static function IMCOT($complexNumber)
|
|
{
|
|
if (is_array($complexNumber)) {
|
|
return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $complexNumber);
|
|
}
|
|
|
|
try {
|
|
$complex = new ComplexObject($complexNumber);
|
|
} catch (ComplexException $e) {
|
|
return ExcelError::NAN();
|
|
}
|
|
|
|
return (string) $complex->cot();
|
|
}
|
|
|
|
/**
|
|
* IMCSC.
|
|
*
|
|
* Returns the cosecant of a complex number in x + yi or x + yj text format.
|
|
*
|
|
* Excel Function:
|
|
* IMCSC(complexNumber)
|
|
*
|
|
* @param array|string $complexNumber the complex number for which you want the cosecant
|
|
* Or can be an array of values
|
|
*
|
|
* @return array|float|string
|
|
* If an array of numbers is passed as an argument, then the returned result will also be an array
|
|
* with the same dimensions
|
|
*/
|
|
public static function IMCSC($complexNumber)
|
|
{
|
|
if (is_array($complexNumber)) {
|
|
return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $complexNumber);
|
|
}
|
|
|
|
try {
|
|
$complex = new ComplexObject($complexNumber);
|
|
} catch (ComplexException $e) {
|
|
return ExcelError::NAN();
|
|
}
|
|
|
|
return (string) $complex->csc();
|
|
}
|
|
|
|
/**
|
|
* IMCSCH.
|
|
*
|
|
* Returns the hyperbolic cosecant of a complex number in x + yi or x + yj text format.
|
|
*
|
|
* Excel Function:
|
|
* IMCSCH(complexNumber)
|
|
*
|
|
* @param array|string $complexNumber the complex number for which you want the hyperbolic cosecant
|
|
* Or can be an array of values
|
|
*
|
|
* @return array|float|string
|
|
* If an array of numbers is passed as an argument, then the returned result will also be an array
|
|
* with the same dimensions
|
|
*/
|
|
public static function IMCSCH($complexNumber)
|
|
{
|
|
if (is_array($complexNumber)) {
|
|
return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $complexNumber);
|
|
}
|
|
|
|
try {
|
|
$complex = new ComplexObject($complexNumber);
|
|
} catch (ComplexException $e) {
|
|
return ExcelError::NAN();
|
|
}
|
|
|
|
return (string) $complex->csch();
|
|
}
|
|
|
|
/**
|
|
* IMSIN.
|
|
*
|
|
* Returns the sine of a complex number in x + yi or x + yj text format.
|
|
*
|
|
* Excel Function:
|
|
* IMSIN(complexNumber)
|
|
*
|
|
* @param array|string $complexNumber the complex number for which you want the sine
|
|
* Or can be an array of values
|
|
*
|
|
* @return array|float|string
|
|
* If an array of numbers is passed as an argument, then the returned result will also be an array
|
|
* with the same dimensions
|
|
*/
|
|
public static function IMSIN($complexNumber)
|
|
{
|
|
if (is_array($complexNumber)) {
|
|
return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $complexNumber);
|
|
}
|
|
|
|
try {
|
|
$complex = new ComplexObject($complexNumber);
|
|
} catch (ComplexException $e) {
|
|
return ExcelError::NAN();
|
|
}
|
|
|
|
return (string) $complex->sin();
|
|
}
|
|
|
|
/**
|
|
* IMSINH.
|
|
*
|
|
* Returns the hyperbolic sine of a complex number in x + yi or x + yj text format.
|
|
*
|
|
* Excel Function:
|
|
* IMSINH(complexNumber)
|
|
*
|
|
* @param array|string $complexNumber the complex number for which you want the hyperbolic sine
|
|
* Or can be an array of values
|
|
*
|
|
* @return array|float|string
|
|
* If an array of numbers is passed as an argument, then the returned result will also be an array
|
|
* with the same dimensions
|
|
*/
|
|
public static function IMSINH($complexNumber)
|
|
{
|
|
if (is_array($complexNumber)) {
|
|
return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $complexNumber);
|
|
}
|
|
|
|
try {
|
|
$complex = new ComplexObject($complexNumber);
|
|
} catch (ComplexException $e) {
|
|
return ExcelError::NAN();
|
|
}
|
|
|
|
return (string) $complex->sinh();
|
|
}
|
|
|
|
/**
|
|
* IMSEC.
|
|
*
|
|
* Returns the secant of a complex number in x + yi or x + yj text format.
|
|
*
|
|
* Excel Function:
|
|
* IMSEC(complexNumber)
|
|
*
|
|
* @param array|string $complexNumber the complex number for which you want the secant
|
|
* Or can be an array of values
|
|
*
|
|
* @return array|float|string
|
|
* If an array of numbers is passed as an argument, then the returned result will also be an array
|
|
* with the same dimensions
|
|
*/
|
|
public static function IMSEC($complexNumber)
|
|
{
|
|
if (is_array($complexNumber)) {
|
|
return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $complexNumber);
|
|
}
|
|
|
|
try {
|
|
$complex = new ComplexObject($complexNumber);
|
|
} catch (ComplexException $e) {
|
|
return ExcelError::NAN();
|
|
}
|
|
|
|
return (string) $complex->sec();
|
|
}
|
|
|
|
/**
|
|
* IMSECH.
|
|
*
|
|
* Returns the hyperbolic secant of a complex number in x + yi or x + yj text format.
|
|
*
|
|
* Excel Function:
|
|
* IMSECH(complexNumber)
|
|
*
|
|
* @param array|string $complexNumber the complex number for which you want the hyperbolic secant
|
|
* Or can be an array of values
|
|
*
|
|
* @return array|float|string
|
|
* If an array of numbers is passed as an argument, then the returned result will also be an array
|
|
* with the same dimensions
|
|
*/
|
|
public static function IMSECH($complexNumber)
|
|
{
|
|
if (is_array($complexNumber)) {
|
|
return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $complexNumber);
|
|
}
|
|
|
|
try {
|
|
$complex = new ComplexObject($complexNumber);
|
|
} catch (ComplexException $e) {
|
|
return ExcelError::NAN();
|
|
}
|
|
|
|
return (string) $complex->sech();
|
|
}
|
|
|
|
/**
|
|
* IMTAN.
|
|
*
|
|
* Returns the tangent of a complex number in x + yi or x + yj text format.
|
|
*
|
|
* Excel Function:
|
|
* IMTAN(complexNumber)
|
|
*
|
|
* @param array|string $complexNumber the complex number for which you want the tangent
|
|
* Or can be an array of values
|
|
*
|
|
* @return array|float|string
|
|
* If an array of numbers is passed as an argument, then the returned result will also be an array
|
|
* with the same dimensions
|
|
*/
|
|
public static function IMTAN($complexNumber)
|
|
{
|
|
if (is_array($complexNumber)) {
|
|
return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $complexNumber);
|
|
}
|
|
|
|
try {
|
|
$complex = new ComplexObject($complexNumber);
|
|
} catch (ComplexException $e) {
|
|
return ExcelError::NAN();
|
|
}
|
|
|
|
return (string) $complex->tan();
|
|
}
|
|
|
|
/**
|
|
* IMSQRT.
|
|
*
|
|
* Returns the square root of a complex number in x + yi or x + yj text format.
|
|
*
|
|
* Excel Function:
|
|
* IMSQRT(complexNumber)
|
|
*
|
|
* @param array|string $complexNumber the complex number for which you want the square root
|
|
* Or can be an array of values
|
|
*
|
|
* @return array|string
|
|
* If an array of numbers is passed as an argument, then the returned result will also be an array
|
|
* with the same dimensions
|
|
*/
|
|
public static function IMSQRT($complexNumber)
|
|
{
|
|
if (is_array($complexNumber)) {
|
|
return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $complexNumber);
|
|
}
|
|
|
|
try {
|
|
$complex = new ComplexObject($complexNumber);
|
|
} catch (ComplexException $e) {
|
|
return ExcelError::NAN();
|
|
}
|
|
|
|
$theta = self::IMARGUMENT($complexNumber);
|
|
if ($theta === ExcelError::DIV0()) {
|
|
return '0';
|
|
}
|
|
|
|
return (string) $complex->sqrt();
|
|
}
|
|
|
|
/**
|
|
* IMLN.
|
|
*
|
|
* Returns the natural logarithm of a complex number in x + yi or x + yj text format.
|
|
*
|
|
* Excel Function:
|
|
* IMLN(complexNumber)
|
|
*
|
|
* @param array|string $complexNumber the complex number for which you want the natural logarithm
|
|
* Or can be an array of values
|
|
*
|
|
* @return array|string
|
|
* If an array of numbers is passed as an argument, then the returned result will also be an array
|
|
* with the same dimensions
|
|
*/
|
|
public static function IMLN($complexNumber)
|
|
{
|
|
if (is_array($complexNumber)) {
|
|
return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $complexNumber);
|
|
}
|
|
|
|
try {
|
|
$complex = new ComplexObject($complexNumber);
|
|
} catch (ComplexException $e) {
|
|
return ExcelError::NAN();
|
|
}
|
|
|
|
if ($complex->getReal() == 0.0 && $complex->getImaginary() == 0.0) {
|
|
return ExcelError::NAN();
|
|
}
|
|
|
|
return (string) $complex->ln();
|
|
}
|
|
|
|
/**
|
|
* IMLOG10.
|
|
*
|
|
* Returns the common logarithm (base 10) of a complex number in x + yi or x + yj text format.
|
|
*
|
|
* Excel Function:
|
|
* IMLOG10(complexNumber)
|
|
*
|
|
* @param array|string $complexNumber the complex number for which you want the common logarithm
|
|
* Or can be an array of values
|
|
*
|
|
* @return array|string
|
|
* If an array of numbers is passed as an argument, then the returned result will also be an array
|
|
* with the same dimensions
|
|
*/
|
|
public static function IMLOG10($complexNumber)
|
|
{
|
|
if (is_array($complexNumber)) {
|
|
return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $complexNumber);
|
|
}
|
|
|
|
try {
|
|
$complex = new ComplexObject($complexNumber);
|
|
} catch (ComplexException $e) {
|
|
return ExcelError::NAN();
|
|
}
|
|
|
|
if ($complex->getReal() == 0.0 && $complex->getImaginary() == 0.0) {
|
|
return ExcelError::NAN();
|
|
}
|
|
|
|
return (string) $complex->log10();
|
|
}
|
|
|
|
/**
|
|
* IMLOG2.
|
|
*
|
|
* Returns the base-2 logarithm of a complex number in x + yi or x + yj text format.
|
|
*
|
|
* Excel Function:
|
|
* IMLOG2(complexNumber)
|
|
*
|
|
* @param array|string $complexNumber the complex number for which you want the base-2 logarithm
|
|
* Or can be an array of values
|
|
*
|
|
* @return array|string
|
|
* If an array of numbers is passed as an argument, then the returned result will also be an array
|
|
* with the same dimensions
|
|
*/
|
|
public static function IMLOG2($complexNumber)
|
|
{
|
|
if (is_array($complexNumber)) {
|
|
return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $complexNumber);
|
|
}
|
|
|
|
try {
|
|
$complex = new ComplexObject($complexNumber);
|
|
} catch (ComplexException $e) {
|
|
return ExcelError::NAN();
|
|
}
|
|
|
|
if ($complex->getReal() == 0.0 && $complex->getImaginary() == 0.0) {
|
|
return ExcelError::NAN();
|
|
}
|
|
|
|
return (string) $complex->log2();
|
|
}
|
|
|
|
/**
|
|
* IMEXP.
|
|
*
|
|
* Returns the exponential of a complex number in x + yi or x + yj text format.
|
|
*
|
|
* Excel Function:
|
|
* IMEXP(complexNumber)
|
|
*
|
|
* @param array|string $complexNumber the complex number for which you want the exponential
|
|
* Or can be an array of values
|
|
*
|
|
* @return array|string
|
|
* If an array of numbers is passed as an argument, then the returned result will also be an array
|
|
* with the same dimensions
|
|
*/
|
|
public static function IMEXP($complexNumber)
|
|
{
|
|
if (is_array($complexNumber)) {
|
|
return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $complexNumber);
|
|
}
|
|
|
|
try {
|
|
$complex = new ComplexObject($complexNumber);
|
|
} catch (ComplexException $e) {
|
|
return ExcelError::NAN();
|
|
}
|
|
|
|
return (string) $complex->exp();
|
|
}
|
|
|
|
/**
|
|
* IMPOWER.
|
|
*
|
|
* Returns a complex number in x + yi or x + yj text format raised to a power.
|
|
*
|
|
* Excel Function:
|
|
* IMPOWER(complexNumber,realNumber)
|
|
*
|
|
* @param array|string $complexNumber the complex number you want to raise to a power
|
|
* Or can be an array of values
|
|
* @param array|float|int|string $realNumber the power to which you want to raise the complex number
|
|
* Or can be an array of values
|
|
*
|
|
* @return array|string
|
|
* If an array of numbers is passed as an argument, then the returned result will also be an array
|
|
* with the same dimensions
|
|
*/
|
|
public static function IMPOWER($complexNumber, $realNumber)
|
|
{
|
|
if (is_array($complexNumber) || is_array($realNumber)) {
|
|
return self::evaluateArrayArguments([self::class, __FUNCTION__], $complexNumber, $realNumber);
|
|
}
|
|
|
|
try {
|
|
$complex = new ComplexObject($complexNumber);
|
|
} catch (ComplexException $e) {
|
|
return ExcelError::NAN();
|
|
}
|
|
|
|
if (!is_numeric($realNumber)) {
|
|
return ExcelError::VALUE();
|
|
}
|
|
|
|
return (string) $complex->pow((float) $realNumber);
|
|
}
|
|
}
|