Search moodle.org's
Developer Documentation
Developer Documentation
- Bug fixes for general core bugs in 4.2.x will end 22 April 2024 (12 months).
- Bug fixes for security issues in 4.2.x will end 7 October 2024 (18 months).
- PHP version: minimum PHP 8.0.0 Note: minimum PHP version has increased since Moodle 4.1. PHP 8.1.x is supported too.
Differences Between: [Versions 310 and 402] [Versions 311 and 402] [Versions 39 and 402] [Versions 400 and 402] [Versions 401 and 402] [Versions 402 and 403]
1 <?php 2 3 namespace PhpOffice\PhpSpreadsheet\Calculation; 4 5 use Complex\Complex; 6 use PhpOffice\PhpSpreadsheet\Calculation\Engineering\ComplexFunctions; 7 use PhpOffice\PhpSpreadsheet\Calculation\Engineering\ComplexOperations; 8 9 /** 10 * @deprecated 1.18.0 11 */ 12 class Engineering 13 { 14 /** 15 * EULER. 16 * 17 * @deprecated 1.18.0 18 * Use Engineering\Constants::EULER instead 19 * @see Engineering\Constants::EULER 20 */ 21 public const EULER = 2.71828182845904523536; 22 23 /** 24 * parseComplex. 25 * 26 * Parses a complex number into its real and imaginary parts, and an I or J suffix 27 * 28 * @deprecated 1.12.0 No longer used by internal code. Please use the \Complex\Complex class instead 29 * 30 * @param string $complexNumber The complex number 31 * 32 * @return mixed[] Indexed on "real", "imaginary" and "suffix" 33 */ 34 public static function parseComplex($complexNumber) 35 { 36 $complex = new Complex($complexNumber); 37 38 return [ 39 'real' => $complex->getReal(), 40 'imaginary' => $complex->getImaginary(), 41 'suffix' => $complex->getSuffix(), 42 ]; 43 } 44 45 /** 46 * BESSELI. 47 * 48 * Returns the modified Bessel function In(x), which is equivalent to the Bessel function evaluated 49 * for purely imaginary arguments 50 * 51 * Excel Function: 52 * BESSELI(x,ord) 53 * 54 * @deprecated 1.17.0 55 * Use the BESSELI() method in the Engineering\BesselI class instead 56 * @see Engineering\BesselI::BESSELI() 57 * 58 * @param float $x The value at which to evaluate the function. 59 * If x is nonnumeric, BESSELI returns the #VALUE! error value. 60 * @param int $ord The order of the Bessel function. 61 * If ord is not an integer, it is truncated. 62 * If $ord is nonnumeric, BESSELI returns the #VALUE! error value. 63 * If $ord < 0, BESSELI returns the #NUM! error value. 64 * 65 * @return array|float|string Result, or a string containing an error 66 */ 67 public static function BESSELI($x, $ord) 68 { 69 return Engineering\BesselI::BESSELI($x, $ord); 70 } 71 72 /** 73 * BESSELJ. 74 * 75 * Returns the Bessel function 76 * 77 * Excel Function: 78 * BESSELJ(x,ord) 79 * 80 * @deprecated 1.17.0 81 * Use the BESSELJ() method in the Engineering\BesselJ class instead 82 * @see Engineering\BesselJ::BESSELJ() 83 * 84 * @param float $x The value at which to evaluate the function. 85 * If x is nonnumeric, BESSELJ returns the #VALUE! error value. 86 * @param int $ord The order of the Bessel function. If n is not an integer, it is truncated. 87 * If $ord is nonnumeric, BESSELJ returns the #VALUE! error value. 88 * If $ord < 0, BESSELJ returns the #NUM! error value. 89 * 90 * @return array|float|string Result, or a string containing an error 91 */ 92 public static function BESSELJ($x, $ord) 93 { 94 return Engineering\BesselJ::BESSELJ($x, $ord); 95 } 96 97 /** 98 * BESSELK. 99 * 100 * Returns the modified Bessel function Kn(x), which is equivalent to the Bessel functions evaluated 101 * for purely imaginary arguments. 102 * 103 * Excel Function: 104 * BESSELK(x,ord) 105 * 106 * @deprecated 1.17.0 107 * Use the BESSELK() method in the Engineering\BesselK class instead 108 * @see Engineering\BesselK::BESSELK() 109 * 110 * @param float $x The value at which to evaluate the function. 111 * If x is nonnumeric, BESSELK returns the #VALUE! error value. 112 * @param int $ord The order of the Bessel function. If n is not an integer, it is truncated. 113 * If $ord is nonnumeric, BESSELK returns the #VALUE! error value. 114 * If $ord < 0, BESSELK returns the #NUM! error value. 115 * 116 * @return array|float|string Result, or a string containing an error 117 */ 118 public static function BESSELK($x, $ord) 119 { 120 return Engineering\BesselK::BESSELK($x, $ord); 121 } 122 123 /** 124 * BESSELY. 125 * 126 * Returns the Bessel function, which is also called the Weber function or the Neumann function. 127 * 128 * Excel Function: 129 * BESSELY(x,ord) 130 * 131 * @deprecated 1.17.0 132 * Use the BESSELY() method in the Engineering\BesselY class instead 133 * @see Engineering\BesselY::BESSELY() 134 * 135 * @param float $x The value at which to evaluate the function. 136 * If x is nonnumeric, BESSELY returns the #VALUE! error value. 137 * @param int $ord The order of the Bessel function. If n is not an integer, it is truncated. 138 * If $ord is nonnumeric, BESSELY returns the #VALUE! error value. 139 * If $ord < 0, BESSELY returns the #NUM! error value. 140 * 141 * @return array|float|string Result, or a string containing an error 142 */ 143 public static function BESSELY($x, $ord) 144 { 145 return Engineering\BesselY::BESSELY($x, $ord); 146 } 147 148 /** 149 * BINTODEC. 150 * 151 * Return a binary value as decimal. 152 * 153 * Excel Function: 154 * BIN2DEC(x) 155 * 156 * @deprecated 1.17.0 157 * Use the toDecimal() method in the Engineering\ConvertBinary class instead 158 * @see Engineering\ConvertBinary::toDecimal() 159 * 160 * @param mixed $x The binary number (as a string) that you want to convert. The number 161 * cannot contain more than 10 characters (10 bits). The most significant 162 * bit of number is the sign bit. The remaining 9 bits are magnitude bits. 163 * Negative numbers are represented using two's-complement notation. 164 * If number is not a valid binary number, or if number contains more than 165 * 10 characters (10 bits), BIN2DEC returns the #NUM! error value. 166 * 167 * @return array|string 168 */ 169 public static function BINTODEC($x) 170 { 171 return Engineering\ConvertBinary::toDecimal($x); 172 } 173 174 /** 175 * BINTOHEX. 176 * 177 * Return a binary value as hex. 178 * 179 * Excel Function: 180 * BIN2HEX(x[,places]) 181 * 182 * @deprecated 1.17.0 183 * Use the toHex() method in the Engineering\ConvertBinary class instead 184 * @see Engineering\ConvertBinary::toHex() 185 * 186 * @param mixed $x The binary number (as a string) that you want to convert. The number 187 * cannot contain more than 10 characters (10 bits). The most significant 188 * bit of number is the sign bit. The remaining 9 bits are magnitude bits. 189 * Negative numbers are represented using two's-complement notation. 190 * If number is not a valid binary number, or if number contains more than 191 * 10 characters (10 bits), BIN2HEX returns the #NUM! error value. 192 * @param mixed $places The number of characters to use. If places is omitted, BIN2HEX uses the 193 * minimum number of characters necessary. Places is useful for padding the 194 * return value with leading 0s (zeros). 195 * If places is not an integer, it is truncated. 196 * If places is nonnumeric, BIN2HEX returns the #VALUE! error value. 197 * If places is negative, BIN2HEX returns the #NUM! error value. 198 * 199 * @return array|string 200 */ 201 public static function BINTOHEX($x, $places = null) 202 { 203 return Engineering\ConvertBinary::toHex($x, $places); 204 } 205 206 /** 207 * BINTOOCT. 208 * 209 * Return a binary value as octal. 210 * 211 * Excel Function: 212 * BIN2OCT(x[,places]) 213 * 214 * @deprecated 1.17.0 215 * Use the toOctal() method in the Engineering\ConvertBinary class instead 216 * @see Engineering\ConvertBinary::toOctal() 217 * 218 * @param mixed $x The binary number (as a string) that you want to convert. The number 219 * cannot contain more than 10 characters (10 bits). The most significant 220 * bit of number is the sign bit. The remaining 9 bits are magnitude bits. 221 * Negative numbers are represented using two's-complement notation. 222 * If number is not a valid binary number, or if number contains more than 223 * 10 characters (10 bits), BIN2OCT returns the #NUM! error value. 224 * @param mixed $places The number of characters to use. If places is omitted, BIN2OCT uses the 225 * minimum number of characters necessary. Places is useful for padding the 226 * return value with leading 0s (zeros). 227 * If places is not an integer, it is truncated. 228 * If places is nonnumeric, BIN2OCT returns the #VALUE! error value. 229 * If places is negative, BIN2OCT returns the #NUM! error value. 230 * 231 * @return array|string 232 */ 233 public static function BINTOOCT($x, $places = null) 234 { 235 return Engineering\ConvertBinary::toOctal($x, $places); 236 } 237 238 /** 239 * DECTOBIN. 240 * 241 * Return a decimal value as binary. 242 * 243 * Excel Function: 244 * DEC2BIN(x[,places]) 245 * 246 * @deprecated 1.17.0 247 * Use the toBinary() method in the Engineering\ConvertDecimal class instead 248 * @see Engineering\ConvertDecimal::toBinary() 249 * 250 * @param mixed $x The decimal integer you want to convert. If number is negative, 251 * valid place values are ignored and DEC2BIN returns a 10-character 252 * (10-bit) binary number in which the most significant bit is the sign 253 * bit. The remaining 9 bits are magnitude bits. Negative numbers are 254 * represented using two's-complement notation. 255 * If number < -512 or if number > 511, DEC2BIN returns the #NUM! error 256 * value. 257 * If number is nonnumeric, DEC2BIN returns the #VALUE! error value. 258 * If DEC2BIN requires more than places characters, it returns the #NUM! 259 * error value. 260 * @param mixed $places The number of characters to use. If places is omitted, DEC2BIN uses 261 * the minimum number of characters necessary. Places is useful for 262 * padding the return value with leading 0s (zeros). 263 * If places is not an integer, it is truncated. 264 * If places is nonnumeric, DEC2BIN returns the #VALUE! error value. 265 * If places is zero or negative, DEC2BIN returns the #NUM! error value. 266 * 267 * @return array|string 268 */ 269 public static function DECTOBIN($x, $places = null) 270 { 271 return Engineering\ConvertDecimal::toBinary($x, $places); 272 } 273 274 /** 275 * DECTOHEX. 276 * 277 * Return a decimal value as hex. 278 * 279 * Excel Function: 280 * DEC2HEX(x[,places]) 281 * 282 * @deprecated 1.17.0 283 * Use the toHex() method in the Engineering\ConvertDecimal class instead 284 * @see Engineering\ConvertDecimal::toHex() 285 * 286 * @param mixed $x The decimal integer you want to convert. If number is negative, 287 * places is ignored and DEC2HEX returns a 10-character (40-bit) 288 * hexadecimal number in which the most significant bit is the sign 289 * bit. The remaining 39 bits are magnitude bits. Negative numbers 290 * are represented using two's-complement notation. 291 * If number < -549,755,813,888 or if number > 549,755,813,887, 292 * DEC2HEX returns the #NUM! error value. 293 * If number is nonnumeric, DEC2HEX returns the #VALUE! error value. 294 * If DEC2HEX requires more than places characters, it returns the 295 * #NUM! error value. 296 * @param mixed $places The number of characters to use. If places is omitted, DEC2HEX uses 297 * the minimum number of characters necessary. Places is useful for 298 * padding the return value with leading 0s (zeros). 299 * If places is not an integer, it is truncated. 300 * If places is nonnumeric, DEC2HEX returns the #VALUE! error value. 301 * If places is zero or negative, DEC2HEX returns the #NUM! error value. 302 * 303 * @return array|string 304 */ 305 public static function DECTOHEX($x, $places = null) 306 { 307 return Engineering\ConvertDecimal::toHex($x, $places); 308 } 309 310 /** 311 * DECTOOCT. 312 * 313 * Return an decimal value as octal. 314 * 315 * Excel Function: 316 * DEC2OCT(x[,places]) 317 * 318 * @deprecated 1.17.0 319 * Use the toOctal() method in the Engineering\ConvertDecimal class instead 320 * @see Engineering\ConvertDecimal::toOctal() 321 * 322 * @param mixed $x The decimal integer you want to convert. If number is negative, 323 * places is ignored and DEC2OCT returns a 10-character (30-bit) 324 * octal number in which the most significant bit is the sign bit. 325 * The remaining 29 bits are magnitude bits. Negative numbers are 326 * represented using two's-complement notation. 327 * If number < -536,870,912 or if number > 536,870,911, DEC2OCT 328 * returns the #NUM! error value. 329 * If number is nonnumeric, DEC2OCT returns the #VALUE! error value. 330 * If DEC2OCT requires more than places characters, it returns the 331 * #NUM! error value. 332 * @param mixed $places The number of characters to use. If places is omitted, DEC2OCT uses 333 * the minimum number of characters necessary. Places is useful for 334 * padding the return value with leading 0s (zeros). 335 * If places is not an integer, it is truncated. 336 * If places is nonnumeric, DEC2OCT returns the #VALUE! error value. 337 * If places is zero or negative, DEC2OCT returns the #NUM! error value. 338 * 339 * @return array|string 340 */ 341 public static function DECTOOCT($x, $places = null) 342 { 343 return Engineering\ConvertDecimal::toOctal($x, $places); 344 } 345 346 /** 347 * HEXTOBIN. 348 * 349 * Return a hex value as binary. 350 * 351 * Excel Function: 352 * HEX2BIN(x[,places]) 353 * 354 * @deprecated 1.17.0 355 * Use the toBinary() method in the Engineering\ConvertHex class instead 356 * @see Engineering\ConvertHex::toBinary() 357 * 358 * @param mixed $x the hexadecimal number (as a string) that you want to convert. 359 * Number cannot contain more than 10 characters. 360 * The most significant bit of number is the sign bit (40th bit from the right). 361 * The remaining 9 bits are magnitude bits. 362 * Negative numbers are represented using two's-complement notation. 363 * If number is negative, HEX2BIN ignores places and returns a 10-character binary number. 364 * If number is negative, it cannot be less than FFFFFFFE00, 365 * and if number is positive, it cannot be greater than 1FF. 366 * If number is not a valid hexadecimal number, HEX2BIN returns the #NUM! error value. 367 * If HEX2BIN requires more than places characters, it returns the #NUM! error value. 368 * @param mixed $places The number of characters to use. If places is omitted, 369 * HEX2BIN uses the minimum number of characters necessary. Places 370 * is useful for padding the return value with leading 0s (zeros). 371 * If places is not an integer, it is truncated. 372 * If places is nonnumeric, HEX2BIN returns the #VALUE! error value. 373 * If places is negative, HEX2BIN returns the #NUM! error value. 374 * 375 * @return array|string 376 */ 377 public static function HEXTOBIN($x, $places = null) 378 { 379 return Engineering\ConvertHex::toBinary($x, $places); 380 } 381 382 /** 383 * HEXTODEC. 384 * 385 * Return a hex value as decimal. 386 * 387 * Excel Function: 388 * HEX2DEC(x) 389 * 390 * @deprecated 1.17.0 391 * Use the toDecimal() method in the Engineering\ConvertHex class instead 392 * @see Engineering\ConvertHex::toDecimal() 393 * 394 * @param mixed $x The hexadecimal number (as a string) that you want to convert. This number cannot 395 * contain more than 10 characters (40 bits). The most significant 396 * bit of number is the sign bit. The remaining 39 bits are magnitude 397 * bits. Negative numbers are represented using two's-complement 398 * notation. 399 * If number is not a valid hexadecimal number, HEX2DEC returns the 400 * #NUM! error value. 401 * 402 * @return array|string 403 */ 404 public static function HEXTODEC($x) 405 { 406 return Engineering\ConvertHex::toDecimal($x); 407 } 408 409 /** 410 * HEXTOOCT. 411 * 412 * Return a hex value as octal. 413 * 414 * Excel Function: 415 * HEX2OCT(x[,places]) 416 * 417 * @deprecated 1.17.0 418 * Use the toOctal() method in the Engineering\ConvertHex class instead 419 * @see Engineering\ConvertHex::toOctal() 420 * 421 * @param mixed $x The hexadecimal number (as a string) that you want to convert. Number cannot 422 * contain more than 10 characters. The most significant bit of 423 * number is the sign bit. The remaining 39 bits are magnitude 424 * bits. Negative numbers are represented using two's-complement 425 * notation. 426 * If number is negative, HEX2OCT ignores places and returns a 427 * 10-character octal number. 428 * If number is negative, it cannot be less than FFE0000000, and 429 * if number is positive, it cannot be greater than 1FFFFFFF. 430 * If number is not a valid hexadecimal number, HEX2OCT returns 431 * the #NUM! error value. 432 * If HEX2OCT requires more than places characters, it returns 433 * the #NUM! error value. 434 * @param mixed $places The number of characters to use. If places is omitted, HEX2OCT 435 * uses the minimum number of characters necessary. Places is 436 * useful for padding the return value with leading 0s (zeros). 437 * If places is not an integer, it is truncated. 438 * If places is nonnumeric, HEX2OCT returns the #VALUE! error 439 * value. 440 * If places is negative, HEX2OCT returns the #NUM! error value. 441 * 442 * @return array|string 443 */ 444 public static function HEXTOOCT($x, $places = null) 445 { 446 return Engineering\ConvertHex::toOctal($x, $places); 447 } 448 449 /** 450 * OCTTOBIN. 451 * 452 * Return an octal value as binary. 453 * 454 * Excel Function: 455 * OCT2BIN(x[,places]) 456 * 457 * @deprecated 1.17.0 458 * Use the toBinary() method in the Engineering\ConvertOctal class instead 459 * @see Engineering\ConvertOctal::toBinary() 460 * 461 * @param mixed $x The octal number you want to convert. Number may not 462 * contain more than 10 characters. The most significant 463 * bit of number is the sign bit. The remaining 29 bits 464 * are magnitude bits. Negative numbers are represented 465 * using two's-complement notation. 466 * If number is negative, OCT2BIN ignores places and returns 467 * a 10-character binary number. 468 * If number is negative, it cannot be less than 7777777000, 469 * and if number is positive, it cannot be greater than 777. 470 * If number is not a valid octal number, OCT2BIN returns 471 * the #NUM! error value. 472 * If OCT2BIN requires more than places characters, it 473 * returns the #NUM! error value. 474 * @param mixed $places The number of characters to use. If places is omitted, 475 * OCT2BIN uses the minimum number of characters necessary. 476 * Places is useful for padding the return value with 477 * leading 0s (zeros). 478 * If places is not an integer, it is truncated. 479 * If places is nonnumeric, OCT2BIN returns the #VALUE! 480 * error value. 481 * If places is negative, OCT2BIN returns the #NUM! error 482 * value. 483 * 484 * @return array|string 485 */ 486 public static function OCTTOBIN($x, $places = null) 487 { 488 return Engineering\ConvertOctal::toBinary($x, $places); 489 } 490 491 /** 492 * OCTTODEC. 493 * 494 * Return an octal value as decimal. 495 * 496 * Excel Function: 497 * OCT2DEC(x) 498 * 499 * @deprecated 1.17.0 500 * Use the toDecimal() method in the Engineering\ConvertOctal class instead 501 * @see Engineering\ConvertOctal::toDecimal() 502 * 503 * @param mixed $x The octal number you want to convert. Number may not contain 504 * more than 10 octal characters (30 bits). The most significant 505 * bit of number is the sign bit. The remaining 29 bits are 506 * magnitude bits. Negative numbers are represented using 507 * two's-complement notation. 508 * If number is not a valid octal number, OCT2DEC returns the 509 * #NUM! error value. 510 * 511 * @return array|string 512 */ 513 public static function OCTTODEC($x) 514 { 515 return Engineering\ConvertOctal::toDecimal($x); 516 } 517 518 /** 519 * OCTTOHEX. 520 * 521 * Return an octal value as hex. 522 * 523 * Excel Function: 524 * OCT2HEX(x[,places]) 525 * 526 * @deprecated 1.17.0 527 * Use the toHex() method in the Engineering\ConvertOctal class instead 528 * @see Engineering\ConvertOctal::toHex() 529 * 530 * @param mixed $x The octal number you want to convert. Number may not contain 531 * more than 10 octal characters (30 bits). The most significant 532 * bit of number is the sign bit. The remaining 29 bits are 533 * magnitude bits. Negative numbers are represented using 534 * two's-complement notation. 535 * If number is negative, OCT2HEX ignores places and returns a 536 * 10-character hexadecimal number. 537 * If number is not a valid octal number, OCT2HEX returns the 538 * #NUM! error value. 539 * If OCT2HEX requires more than places characters, it returns 540 * the #NUM! error value. 541 * @param mixed $places The number of characters to use. If places is omitted, OCT2HEX 542 * uses the minimum number of characters necessary. Places is useful 543 * for padding the return value with leading 0s (zeros). 544 * If places is not an integer, it is truncated. 545 * If places is nonnumeric, OCT2HEX returns the #VALUE! error value. 546 * If places is negative, OCT2HEX returns the #NUM! error value. 547 * 548 * @return array|string 549 */ 550 public static function OCTTOHEX($x, $places = null) 551 { 552 return Engineering\ConvertOctal::toHex($x, $places); 553 } 554 555 /** 556 * COMPLEX. 557 * 558 * Converts real and imaginary coefficients into a complex number of the form x +/- yi or x +/- yj. 559 * 560 * Excel Function: 561 * COMPLEX(realNumber,imaginary[,suffix]) 562 * 563 * @deprecated 1.18.0 564 * Use the COMPLEX() method in the Engineering\Complex class instead 565 * @see Engineering\Complex::COMPLEX() 566 * 567 * @param array|float $realNumber the real coefficient of the complex number 568 * @param array|float $imaginary the imaginary coefficient of the complex number 569 * @param array|string $suffix The suffix for the imaginary component of the complex number. 570 * If omitted, the suffix is assumed to be "i". 571 * 572 * @return array|string 573 */ 574 public static function COMPLEX($realNumber = 0.0, $imaginary = 0.0, $suffix = 'i') 575 { 576 return Engineering\Complex::COMPLEX($realNumber, $imaginary, $suffix); 577 } 578 579 /** 580 * IMAGINARY. 581 * 582 * Returns the imaginary coefficient of a complex number in x + yi or x + yj text format. 583 * 584 * Excel Function: 585 * IMAGINARY(complexNumber) 586 * 587 * @deprecated 1.18.0 588 * Use the IMAGINARY() method in the Engineering\Complex class instead 589 * @see Engineering\Complex::IMAGINARY() 590 * 591 * @param string $complexNumber the complex number for which you want the imaginary 592 * coefficient 593 * 594 * @return array|float|string 595 */ 596 public static function IMAGINARY($complexNumber) 597 { 598 return Engineering\Complex::IMAGINARY($complexNumber); 599 } 600 601 /** 602 * IMREAL. 603 * 604 * Returns the real coefficient of a complex number in x + yi or x + yj text format. 605 * 606 * Excel Function: 607 * IMREAL(complexNumber) 608 * 609 * @deprecated 1.18.0 610 * Use the IMREAL() method in the Engineering\Complex class instead 611 * @see Engineering\Complex::IMREAL() 612 * 613 * @param string $complexNumber the complex number for which you want the real coefficient 614 * 615 * @return array|float|string 616 */ 617 public static function IMREAL($complexNumber) 618 { 619 return Engineering\Complex::IMREAL($complexNumber); 620 } 621 622 /** 623 * IMABS. 624 * 625 * Returns the absolute value (modulus) of a complex number in x + yi or x + yj text format. 626 * 627 * Excel Function: 628 * IMABS(complexNumber) 629 * 630 * @deprecated 1.18.0 631 * Use the IMABS() method in the Engineering\ComplexFunctions class instead 632 * @see ComplexFunctions::IMABS() 633 * 634 * @param string $complexNumber the complex number for which you want the absolute value 635 * 636 * @return array|float|string 637 */ 638 public static function IMABS($complexNumber) 639 { 640 return ComplexFunctions::IMABS($complexNumber); 641 } 642 643 /** 644 * IMARGUMENT. 645 * 646 * Returns the argument theta of a complex number, i.e. the angle in radians from the real 647 * axis to the representation of the number in polar coordinates. 648 * 649 * Excel Function: 650 * IMARGUMENT(complexNumber) 651 * 652 * @deprecated 1.18.0 653 * Use the IMARGUMENT() method in the Engineering\ComplexFunctions class instead 654 * @see ComplexFunctions::IMARGUMENT() 655 * 656 * @param array|string $complexNumber the complex number for which you want the argument theta 657 * 658 * @return array|float|string 659 */ 660 public static function IMARGUMENT($complexNumber) 661 { 662 return ComplexFunctions::IMARGUMENT($complexNumber); 663 } 664 665 /** 666 * IMCONJUGATE. 667 * 668 * Returns the complex conjugate of a complex number in x + yi or x + yj text format. 669 * 670 * Excel Function: 671 * IMCONJUGATE(complexNumber) 672 * 673 * @deprecated 1.18.0 674 * Use the IMCONJUGATE() method in the Engineering\ComplexFunctions class instead 675 * @see ComplexFunctions::IMCONJUGATE() 676 * 677 * @param array|string $complexNumber the complex number for which you want the conjugate 678 * 679 * @return array|string 680 */ 681 public static function IMCONJUGATE($complexNumber) 682 { 683 return ComplexFunctions::IMCONJUGATE($complexNumber); 684 } 685 686 /** 687 * IMCOS. 688 * 689 * Returns the cosine of a complex number in x + yi or x + yj text format. 690 * 691 * Excel Function: 692 * IMCOS(complexNumber) 693 * 694 * @deprecated 1.18.0 695 * Use the IMCOS() method in the Engineering\ComplexFunctions class instead 696 * @see ComplexFunctions::IMCOS() 697 * 698 * @param array|string $complexNumber the complex number for which you want the cosine 699 * 700 * @return array|float|string 701 */ 702 public static function IMCOS($complexNumber) 703 { 704 return ComplexFunctions::IMCOS($complexNumber); 705 } 706 707 /** 708 * IMCOSH. 709 * 710 * Returns the hyperbolic cosine of a complex number in x + yi or x + yj text format. 711 * 712 * Excel Function: 713 * IMCOSH(complexNumber) 714 * 715 * @deprecated 1.18.0 716 * Use the IMCOSH() method in the Engineering\ComplexFunctions class instead 717 * @see ComplexFunctions::IMCOSH() 718 * 719 * @param array|string $complexNumber the complex number for which you want the hyperbolic cosine 720 * 721 * @return array|float|string 722 */ 723 public static function IMCOSH($complexNumber) 724 { 725 return ComplexFunctions::IMCOSH($complexNumber); 726 } 727 728 /** 729 * IMCOT. 730 * 731 * Returns the cotangent of a complex number in x + yi or x + yj text format. 732 * 733 * Excel Function: 734 * IMCOT(complexNumber) 735 * 736 * @deprecated 1.18.0 737 * Use the IMCOT() method in the Engineering\ComplexFunctions class instead 738 * @see ComplexFunctions::IMCOT() 739 * 740 * @param array|string $complexNumber the complex number for which you want the cotangent 741 * 742 * @return array|float|string 743 */ 744 public static function IMCOT($complexNumber) 745 { 746 return ComplexFunctions::IMCOT($complexNumber); 747 } 748 749 /** 750 * IMCSC. 751 * 752 * Returns the cosecant of a complex number in x + yi or x + yj text format. 753 * 754 * Excel Function: 755 * IMCSC(complexNumber) 756 * 757 * @deprecated 1.18.0 758 * Use the IMCSC() method in the Engineering\ComplexFunctions class instead 759 * @see ComplexFunctions::IMCSC() 760 * 761 * @param array|string $complexNumber the complex number for which you want the cosecant 762 * 763 * @return array|float|string 764 */ 765 public static function IMCSC($complexNumber) 766 { 767 return ComplexFunctions::IMCSC($complexNumber); 768 } 769 770 /** 771 * IMCSCH. 772 * 773 * Returns the hyperbolic cosecant of a complex number in x + yi or x + yj text format. 774 * 775 * Excel Function: 776 * IMCSCH(complexNumber) 777 * 778 * @deprecated 1.18.0 779 * Use the IMCSCH() method in the Engineering\ComplexFunctions class instead 780 * @see ComplexFunctions::IMCSCH() 781 * 782 * @param array|string $complexNumber the complex number for which you want the hyperbolic cosecant 783 * 784 * @return array|float|string 785 */ 786 public static function IMCSCH($complexNumber) 787 { 788 return ComplexFunctions::IMCSCH($complexNumber); 789 } 790 791 /** 792 * IMSIN. 793 * 794 * Returns the sine of a complex number in x + yi or x + yj text format. 795 * 796 * Excel Function: 797 * IMSIN(complexNumber) 798 * 799 * @deprecated 1.18.0 800 * Use the IMSIN() method in the Engineering\ComplexFunctions class instead 801 * @see ComplexFunctions::IMSIN() 802 * 803 * @param string $complexNumber the complex number for which you want the sine 804 * 805 * @return array|float|string 806 */ 807 public static function IMSIN($complexNumber) 808 { 809 return ComplexFunctions::IMSIN($complexNumber); 810 } 811 812 /** 813 * IMSINH. 814 * 815 * Returns the hyperbolic sine of a complex number in x + yi or x + yj text format. 816 * 817 * Excel Function: 818 * IMSINH(complexNumber) 819 * 820 * @deprecated 1.18.0 821 * Use the IMSINH() method in the Engineering\ComplexFunctions class instead 822 * @see ComplexFunctions::IMSINH() 823 * 824 * @param string $complexNumber the complex number for which you want the hyperbolic sine 825 * 826 * @return array|float|string 827 */ 828 public static function IMSINH($complexNumber) 829 { 830 return ComplexFunctions::IMSINH($complexNumber); 831 } 832 833 /** 834 * IMSEC. 835 * 836 * Returns the secant of a complex number in x + yi or x + yj text format. 837 * 838 * Excel Function: 839 * IMSEC(complexNumber) 840 * 841 * @deprecated 1.18.0 842 * Use the IMSEC() method in the Engineering\ComplexFunctions class instead 843 * @see ComplexFunctions::IMSEC() 844 * 845 * @param string $complexNumber the complex number for which you want the secant 846 * 847 * @return array|float|string 848 */ 849 public static function IMSEC($complexNumber) 850 { 851 return ComplexFunctions::IMSEC($complexNumber); 852 } 853 854 /** 855 * IMSECH. 856 * 857 * Returns the hyperbolic secant of a complex number in x + yi or x + yj text format. 858 * 859 * Excel Function: 860 * IMSECH(complexNumber) 861 * 862 * @deprecated 1.18.0 863 * Use the IMSECH() method in the Engineering\ComplexFunctions class instead 864 * @see ComplexFunctions::IMSECH() 865 * 866 * @param string $complexNumber the complex number for which you want the hyperbolic secant 867 * 868 * @return array|float|string 869 */ 870 public static function IMSECH($complexNumber) 871 { 872 return ComplexFunctions::IMSECH($complexNumber); 873 } 874 875 /** 876 * IMTAN. 877 * 878 * Returns the tangent of a complex number in x + yi or x + yj text format. 879 * 880 * Excel Function: 881 * IMTAN(complexNumber) 882 * 883 * @deprecated 1.18.0 884 * Use the IMTAN() method in the Engineering\ComplexFunctions class instead 885 * @see ComplexFunctions::IMTAN() 886 * 887 * @param string $complexNumber the complex number for which you want the tangent 888 * 889 * @return array|float|string 890 */ 891 public static function IMTAN($complexNumber) 892 { 893 return ComplexFunctions::IMTAN($complexNumber); 894 } 895 896 /** 897 * IMSQRT. 898 * 899 * Returns the square root of a complex number in x + yi or x + yj text format. 900 * 901 * Excel Function: 902 * IMSQRT(complexNumber) 903 * 904 * @deprecated 1.18.0 905 * Use the IMSQRT() method in the Engineering\ComplexFunctions class instead 906 * @see ComplexFunctions::IMSQRT() 907 * 908 * @param string $complexNumber the complex number for which you want the square root 909 * 910 * @return array|string 911 */ 912 public static function IMSQRT($complexNumber) 913 { 914 return ComplexFunctions::IMSQRT($complexNumber); 915 } 916 917 /** 918 * IMLN. 919 * 920 * Returns the natural logarithm of a complex number in x + yi or x + yj text format. 921 * 922 * Excel Function: 923 * IMLN(complexNumber) 924 * 925 * @deprecated 1.18.0 926 * Use the IMLN() method in the Engineering\ComplexFunctions class instead 927 * @see ComplexFunctions::IMLN() 928 * 929 * @param string $complexNumber the complex number for which you want the natural logarithm 930 * 931 * @return array|string 932 */ 933 public static function IMLN($complexNumber) 934 { 935 return ComplexFunctions::IMLN($complexNumber); 936 } 937 938 /** 939 * IMLOG10. 940 * 941 * Returns the common logarithm (base 10) of a complex number in x + yi or x + yj text format. 942 * 943 * Excel Function: 944 * IMLOG10(complexNumber) 945 * 946 * @deprecated 1.18.0 947 * Use the IMLOG10() method in the Engineering\ComplexFunctions class instead 948 * @see ComplexFunctions::IMLOG10() 949 * 950 * @param string $complexNumber the complex number for which you want the common logarithm 951 * 952 * @return array|string 953 */ 954 public static function IMLOG10($complexNumber) 955 { 956 return ComplexFunctions::IMLOG10($complexNumber); 957 } 958 959 /** 960 * IMLOG2. 961 * 962 * Returns the base-2 logarithm of a complex number in x + yi or x + yj text format. 963 * 964 * Excel Function: 965 * IMLOG2(complexNumber) 966 * 967 * @deprecated 1.18.0 968 * Use the IMLOG2() method in the Engineering\ComplexFunctions class instead 969 * @see ComplexFunctions::IMLOG2() 970 * 971 * @param string $complexNumber the complex number for which you want the base-2 logarithm 972 * 973 * @return array|string 974 */ 975 public static function IMLOG2($complexNumber) 976 { 977 return ComplexFunctions::IMLOG2($complexNumber); 978 } 979 980 /** 981 * IMEXP. 982 * 983 * Returns the exponential of a complex number in x + yi or x + yj text format. 984 * 985 * Excel Function: 986 * IMEXP(complexNumber) 987 * 988 * @deprecated 1.18.0 989 * Use the IMEXP() method in the Engineering\ComplexFunctions class instead 990 * @see ComplexFunctions::IMEXP() 991 * 992 * @param string $complexNumber the complex number for which you want the exponential 993 * 994 * @return array|string 995 */ 996 public static function IMEXP($complexNumber) 997 { 998 return ComplexFunctions::IMEXP($complexNumber); 999 } 1000 1001 /** 1002 * IMPOWER. 1003 * 1004 * Returns a complex number in x + yi or x + yj text format raised to a power. 1005 * 1006 * Excel Function: 1007 * IMPOWER(complexNumber,realNumber) 1008 * 1009 * @deprecated 1.18.0 1010 * Use the IMPOWER() method in the Engineering\ComplexFunctions class instead 1011 * @see ComplexFunctions::IMPOWER() 1012 * 1013 * @param string $complexNumber the complex number you want to raise to a power 1014 * @param float $realNumber the power to which you want to raise the complex number 1015 * 1016 * @return array|string 1017 */ 1018 public static function IMPOWER($complexNumber, $realNumber) 1019 { 1020 return ComplexFunctions::IMPOWER($complexNumber, $realNumber); 1021 } 1022 1023 /** 1024 * IMDIV. 1025 * 1026 * Returns the quotient of two complex numbers in x + yi or x + yj text format. 1027 * 1028 * Excel Function: 1029 * IMDIV(complexDividend,complexDivisor) 1030 * 1031 * @deprecated 1.18.0 1032 * Use the IMDIV() method in the Engineering\ComplexOperations class instead 1033 * @see ComplexOperations::IMDIV() 1034 * 1035 * @param string $complexDividend the complex numerator or dividend 1036 * @param string $complexDivisor the complex denominator or divisor 1037 * 1038 * @return array|string 1039 */ 1040 public static function IMDIV($complexDividend, $complexDivisor) 1041 { 1042 return ComplexOperations::IMDIV($complexDividend, $complexDivisor); 1043 } 1044 1045 /** 1046 * IMSUB. 1047 * 1048 * Returns the difference of two complex numbers in x + yi or x + yj text format. 1049 * 1050 * Excel Function: 1051 * IMSUB(complexNumber1,complexNumber2) 1052 * 1053 * @deprecated 1.18.0 1054 * Use the IMSUB() method in the Engineering\ComplexOperations class instead 1055 * @see ComplexOperations::IMSUB() 1056 * 1057 * @param string $complexNumber1 the complex number from which to subtract complexNumber2 1058 * @param string $complexNumber2 the complex number to subtract from complexNumber1 1059 * 1060 * @return array|string 1061 */ 1062 public static function IMSUB($complexNumber1, $complexNumber2) 1063 { 1064 return ComplexOperations::IMSUB($complexNumber1, $complexNumber2); 1065 } 1066 1067 /** 1068 * IMSUM. 1069 * 1070 * Returns the sum of two or more complex numbers in x + yi or x + yj text format. 1071 * 1072 * Excel Function: 1073 * IMSUM(complexNumber[,complexNumber[,...]]) 1074 * 1075 * @deprecated 1.18.0 1076 * Use the IMSUM() method in the Engineering\ComplexOperations class instead 1077 * @see ComplexOperations::IMSUM() 1078 * 1079 * @param string ...$complexNumbers Series of complex numbers to add 1080 * 1081 * @return string 1082 */ 1083 public static function IMSUM(...$complexNumbers) 1084 { 1085 return ComplexOperations::IMSUM(...$complexNumbers); 1086 } 1087 1088 /** 1089 * IMPRODUCT. 1090 * 1091 * Returns the product of two or more complex numbers in x + yi or x + yj text format. 1092 * 1093 * Excel Function: 1094 * IMPRODUCT(complexNumber[,complexNumber[,...]]) 1095 * 1096 * @deprecated 1.18.0 1097 * Use the IMPRODUCT() method in the Engineering\ComplexOperations class instead 1098 * @see ComplexOperations::IMPRODUCT() 1099 * 1100 * @param string ...$complexNumbers Series of complex numbers to multiply 1101 * 1102 * @return string 1103 */ 1104 public static function IMPRODUCT(...$complexNumbers) 1105 { 1106 return ComplexOperations::IMPRODUCT(...$complexNumbers); 1107 } 1108 1109 /** 1110 * DELTA. 1111 * 1112 * Tests whether two values are equal. Returns 1 if number1 = number2; returns 0 otherwise. 1113 * Use this function to filter a set of values. For example, by summing several DELTA 1114 * functions you calculate the count of equal pairs. This function is also known as the 1115 * Kronecker Delta function. 1116 * 1117 * Excel Function: 1118 * DELTA(a[,b]) 1119 * 1120 * @deprecated 1.17.0 1121 * Use the DELTA() method in the Engineering\Compare class instead 1122 * @see Engineering\Compare::DELTA() 1123 * 1124 * @param float $a the first number 1125 * @param float $b The second number. If omitted, b is assumed to be zero. 1126 * 1127 * @return array|int|string (string in the event of an error) 1128 */ 1129 public static function DELTA($a, $b = 0) 1130 { 1131 return Engineering\Compare::DELTA($a, $b); 1132 } 1133 1134 /** 1135 * GESTEP. 1136 * 1137 * Excel Function: 1138 * GESTEP(number[,step]) 1139 * 1140 * Returns 1 if number >= step; returns 0 (zero) otherwise 1141 * Use this function to filter a set of values. For example, by summing several GESTEP 1142 * functions you calculate the count of values that exceed a threshold. 1143 * 1144 * @deprecated 1.17.0 1145 * Use the GESTEP() method in the Engineering\Compare class instead 1146 * @see Engineering\Compare::GESTEP() 1147 * 1148 * @param float $number the value to test against step 1149 * @param float $step The threshold value. If you omit a value for step, GESTEP uses zero. 1150 * 1151 * @return array|int|string (string in the event of an error) 1152 */ 1153 public static function GESTEP($number, $step = 0) 1154 { 1155 return Engineering\Compare::GESTEP($number, $step); 1156 } 1157 1158 /** 1159 * BITAND. 1160 * 1161 * Returns the bitwise AND of two integer values. 1162 * 1163 * Excel Function: 1164 * BITAND(number1, number2) 1165 * 1166 * @deprecated 1.17.0 1167 * Use the BITAND() method in the Engineering\BitWise class instead 1168 * @see Engineering\BitWise::BITAND() 1169 * 1170 * @param int $number1 1171 * @param int $number2 1172 * 1173 * @return array|int|string 1174 */ 1175 public static function BITAND($number1, $number2) 1176 { 1177 return Engineering\BitWise::BITAND($number1, $number2); 1178 } 1179 1180 /** 1181 * BITOR. 1182 * 1183 * Returns the bitwise OR of two integer values. 1184 * 1185 * Excel Function: 1186 * BITOR(number1, number2) 1187 * 1188 * @deprecated 1.17.0 1189 * Use the BITOR() method in the Engineering\BitWise class instead 1190 * @see Engineering\BitWise::BITOR() 1191 * 1192 * @param int $number1 1193 * @param int $number2 1194 * 1195 * @return array|int|string 1196 */ 1197 public static function BITOR($number1, $number2) 1198 { 1199 return Engineering\BitWise::BITOR($number1, $number2); 1200 } 1201 1202 /** 1203 * BITXOR. 1204 * 1205 * Returns the bitwise XOR of two integer values. 1206 * 1207 * Excel Function: 1208 * BITXOR(number1, number2) 1209 * 1210 * @deprecated 1.17.0 1211 * Use the BITXOR() method in the Engineering\BitWise class instead 1212 * @see Engineering\BitWise::BITXOR() 1213 * 1214 * @param int $number1 1215 * @param int $number2 1216 * 1217 * @return array|int|string 1218 */ 1219 public static function BITXOR($number1, $number2) 1220 { 1221 return Engineering\BitWise::BITXOR($number1, $number2); 1222 } 1223 1224 /** 1225 * BITLSHIFT. 1226 * 1227 * Returns the number value shifted left by shift_amount bits. 1228 * 1229 * Excel Function: 1230 * BITLSHIFT(number, shift_amount) 1231 * 1232 * @deprecated 1.17.0 1233 * Use the BITLSHIFT() method in the Engineering\BitWise class instead 1234 * @see Engineering\BitWise::BITLSHIFT() 1235 * 1236 * @param int $number 1237 * @param int $shiftAmount 1238 * 1239 * @return array|float|int|string 1240 */ 1241 public static function BITLSHIFT($number, $shiftAmount) 1242 { 1243 return Engineering\BitWise::BITLSHIFT($number, $shiftAmount); 1244 } 1245 1246 /** 1247 * BITRSHIFT. 1248 * 1249 * Returns the number value shifted right by shift_amount bits. 1250 * 1251 * Excel Function: 1252 * BITRSHIFT(number, shift_amount) 1253 * 1254 * @deprecated 1.17.0 1255 * Use the BITRSHIFT() method in the Engineering\BitWise class instead 1256 * @see Engineering\BitWise::BITRSHIFT() 1257 * 1258 * @param int $number 1259 * @param int $shiftAmount 1260 * 1261 * @return array|float|int|string 1262 */ 1263 public static function BITRSHIFT($number, $shiftAmount) 1264 { 1265 return Engineering\BitWise::BITRSHIFT($number, $shiftAmount); 1266 } 1267 1268 /** 1269 * ERF. 1270 * 1271 * Returns the error function integrated between the lower and upper bound arguments. 1272 * 1273 * Note: In Excel 2007 or earlier, if you input a negative value for the upper or lower bound arguments, 1274 * the function would return a #NUM! error. However, in Excel 2010, the function algorithm was 1275 * improved, so that it can now calculate the function for both positive and negative ranges. 1276 * PhpSpreadsheet follows Excel 2010 behaviour, and accepts negative arguments. 1277 * 1278 * Excel Function: 1279 * ERF(lower[,upper]) 1280 * 1281 * @deprecated 1.17.0 1282 * Use the ERF() method in the Engineering\Erf class instead 1283 * @see Engineering\Erf::ERF() 1284 * 1285 * @param float $lower lower bound for integrating ERF 1286 * @param float $upper upper bound for integrating ERF. 1287 * If omitted, ERF integrates between zero and lower_limit 1288 * 1289 * @return array|float|string 1290 */ 1291 public static function ERF($lower, $upper = null) 1292 { 1293 return Engineering\Erf::ERF($lower, $upper); 1294 } 1295 1296 /** 1297 * ERFPRECISE. 1298 * 1299 * Returns the error function integrated between the lower and upper bound arguments. 1300 * 1301 * Excel Function: 1302 * ERF.PRECISE(limit) 1303 * 1304 * @deprecated 1.17.0 1305 * Use the ERFPRECISE() method in the Engineering\Erf class instead 1306 * @see Engineering\Erf::ERFPRECISE() 1307 * 1308 * @param float $limit bound for integrating ERF 1309 * 1310 * @return array|float|string 1311 */ 1312 public static function ERFPRECISE($limit) 1313 { 1314 return Engineering\Erf::ERFPRECISE($limit); 1315 } 1316 1317 /** 1318 * ERFC. 1319 * 1320 * Returns the complementary ERF function integrated between x and infinity 1321 * 1322 * Note: In Excel 2007 or earlier, if you input a negative value for the lower bound argument, 1323 * the function would return a #NUM! error. However, in Excel 2010, the function algorithm was 1324 * improved, so that it can now calculate the function for both positive and negative x values. 1325 * PhpSpreadsheet follows Excel 2010 behaviour, and accepts nagative arguments. 1326 * 1327 * Excel Function: 1328 * ERFC(x) 1329 * 1330 * @deprecated 1.17.0 1331 * Use the ERFC() method in the Engineering\ErfC class instead 1332 * @see Engineering\ErfC::ERFC() 1333 * 1334 * @param float $x The lower bound for integrating ERFC 1335 * 1336 * @return array|float|string 1337 */ 1338 public static function ERFC($x) 1339 { 1340 return Engineering\ErfC::ERFC($x); 1341 } 1342 1343 /** 1344 * getConversionGroups 1345 * Returns a list of the different conversion groups for UOM conversions. 1346 * 1347 * @deprecated 1.16.0 1348 * Use the getConversionCategories() method in the Engineering\ConvertUOM class instead 1349 * @see Engineering\ConvertUOM::getConversionCategories() 1350 * 1351 * @return array 1352 */ 1353 public static function getConversionGroups() 1354 { 1355 return Engineering\ConvertUOM::getConversionCategories(); 1356 } 1357 1358 /** 1359 * getConversionGroupUnits 1360 * Returns an array of units of measure, for a specified conversion group, or for all groups. 1361 * 1362 * @deprecated 1.16.0 1363 * Use the getConversionCategoryUnits() method in the ConvertUOM class instead 1364 * @see Engineering\ConvertUOM::getConversionCategoryUnits() 1365 * 1366 * @param null|mixed $category 1367 * 1368 * @return array 1369 */ 1370 public static function getConversionGroupUnits($category = null) 1371 { 1372 return Engineering\ConvertUOM::getConversionCategoryUnits($category); 1373 } 1374 1375 /** 1376 * getConversionGroupUnitDetails. 1377 * 1378 * @deprecated 1.16.0 1379 * Use the getConversionCategoryUnitDetails() method in the ConvertUOM class instead 1380 * @see Engineering\ConvertUOM::getConversionCategoryUnitDetails() 1381 * 1382 * @param null|mixed $category 1383 * 1384 * @return array 1385 */ 1386 public static function getConversionGroupUnitDetails($category = null) 1387 { 1388 return Engineering\ConvertUOM::getConversionCategoryUnitDetails($category); 1389 } 1390 1391 /** 1392 * getConversionMultipliers 1393 * Returns an array of the Multiplier prefixes that can be used with Units of Measure in CONVERTUOM(). 1394 * 1395 * @deprecated 1.16.0 1396 * Use the getConversionMultipliers() method in the ConvertUOM class instead 1397 * @see Engineering\ConvertUOM::getConversionMultipliers() 1398 * 1399 * @return mixed[] 1400 */ 1401 public static function getConversionMultipliers() 1402 { 1403 return Engineering\ConvertUOM::getConversionMultipliers(); 1404 } 1405 1406 /** 1407 * getBinaryConversionMultipliers. 1408 * 1409 * Returns an array of the additional Multiplier prefixes that can be used with Information Units of Measure 1410 * in CONVERTUOM(). 1411 * 1412 * @deprecated 1.16.0 1413 * Use the getBinaryConversionMultipliers() method in the ConvertUOM class instead 1414 * @see Engineering\ConvertUOM::getBinaryConversionMultipliers() 1415 * 1416 * @return mixed[] 1417 */ 1418 public static function getBinaryConversionMultipliers() 1419 { 1420 return Engineering\ConvertUOM::getBinaryConversionMultipliers(); 1421 } 1422 1423 /** 1424 * CONVERTUOM. 1425 * 1426 * Converts a number from one measurement system to another. 1427 * For example, CONVERT can translate a table of distances in miles to a table of distances 1428 * in kilometers. 1429 * 1430 * Excel Function: 1431 * CONVERT(value,fromUOM,toUOM) 1432 * 1433 * @deprecated 1.16.0 1434 * Use the CONVERT() method in the ConvertUOM class instead 1435 * @see Engineering\ConvertUOM::CONVERT() 1436 * 1437 * @param float|int $value the value in fromUOM to convert 1438 * @param string $fromUOM the units for value 1439 * @param string $toUOM the units for the result 1440 * 1441 * @return array|float|string 1442 */ 1443 public static function CONVERTUOM($value, $fromUOM, $toUOM) 1444 { 1445 return Engineering\ConvertUOM::CONVERT($value, $fromUOM, $toUOM); 1446 } 1447 }
title
Description
Body
title
Description
Body
title
Description
Body
title
Body
