PageRenderTime 64ms CodeModel.GetById 21ms RepoModel.GetById 0ms app.codeStats 1ms

/common/libraries/plugin/phpexcel/PHPExcel/Calculation/Engineering.php

https://bitbucket.org/ywarnier/chamilo-dev
PHP | 2135 lines | 1527 code | 207 blank | 401 comment | 315 complexity | 73769569c2093f011fe8c270a1918df6 MD5 | raw file
Possible License(s): GPL-2.0, BSD-3-Clause, LGPL-2.1, LGPL-3.0, GPL-3.0, MIT 
    

  1. <?php

    2. 

  2. /**
    3. 

  3.  * PHPExcel
    4. 

  4.  *
    5. 

  5.  * Copyright (c) 2006 - 2011 PHPExcel
    6. 

  6.  *
    7. 

  7.  * This library is free software; you can redistribute it and/or
    8. 

  8.  * modify it under the terms of the GNU Lesser General Public
    9. 

  9.  * License as published by the Free Software Foundation; either
    10. 

  10.  * version 2.1 of the License, or (at your option) any later version.
    11. 

  11.  *
    12. 

  12.  * This library is distributed in the hope that it will be useful,
    13. 

  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
    14. 

  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
    15. 

  15.  * Lesser General Public License for more details.
    16. 

  16.  *
    17. 

  17.  * You should have received a copy of the GNU Lesser General Public
    18. 

  18.  * License along with this library; if not, write to the Free Software
    19. 

  19.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
    20. 

  20.  *
    21. 

  21.  * @category	PHPExcel
    22. 

  22.  * @package		PHPExcel_Calculation
    23. 

  23.  * @copyright	Copyright (c) 2006 - 2011 PHPExcel (http://www.codeplex.com/PHPExcel)
    24. 

  24.  * @license		http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt	LGPL
    25. 

  25.  * @version		1.7.6, 2011-02-27
    26. 

  26.  */

    27. 

  27. 

    28. 

  28. /** PHPExcel root directory */

    29. 

  29. if (! defined('PHPEXCEL_ROOT'))

    30. 

  30. {

    31. 

  31.     /**
    32. 

  32.      * @ignore
    33. 

  33.      */

    34. 

  34.     define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../');

    35. 

  35.     require (PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');

    36. 

  36. }

    37. 

  37. 

    38. 

  38. /** EULER */

    39. 

  39. define('EULER', 2.71828182845904523536);

    40. 

  40. 

    41. 

  41. /**
    42. 

  42.  * PHPExcel_Calculation_Engineering
    43. 

  43.  *
    44. 

  44.  * @category	PHPExcel
    45. 

  45.  * @package		PHPExcel_Calculation
    46. 

  46.  * @copyright	Copyright (c) 2006 - 2011 PHPExcel (http://www.codeplex.com/PHPExcel)
    47. 

  47.  */

    48. 

  48. class PHPExcel_Calculation_Engineering

    49. 

  49. {

    50. 

  50.     

    51. 

  51.     private static $_conversionUnits = array(

    52. 

  52.             'g' => array('Group' => 'Mass', 'Unit Name' => 'Gram', 'AllowPrefix' => True), 

    53. 

  53.             'sg' => array('Group' => 'Mass', 'Unit Name' => 'Slug', 'AllowPrefix' => False), 

    54. 

  54.             'lbm' => array('Group' => 'Mass', 'Unit Name' => 'Pound mass (avoirdupois)', 'AllowPrefix' => False), 

    55. 

  55.             'u' => array('Group' => 'Mass', 'Unit Name' => 'U (atomic mass unit)', 'AllowPrefix' => True), 

    56. 

  56.             'ozm' => array('Group' => 'Mass', 'Unit Name' => 'Ounce mass (avoirdupois)', 'AllowPrefix' => False), 

    57. 

  57.             'm' => array('Group' => 'Distance', 'Unit Name' => 'Meter', 'AllowPrefix' => True), 

    58. 

  58.             'mi' => array('Group' => 'Distance', 'Unit Name' => 'Statute mile', 'AllowPrefix' => False), 

    59. 

  59.             'Nmi' => array('Group' => 'Distance', 'Unit Name' => 'Nautical mile', 'AllowPrefix' => False), 

    60. 

  60.             'in' => array('Group' => 'Distance', 'Unit Name' => 'Inch', 'AllowPrefix' => False), 

    61. 

  61.             'ft' => array('Group' => 'Distance', 'Unit Name' => 'Foot', 'AllowPrefix' => False), 

    62. 

  62.             'yd' => array('Group' => 'Distance', 'Unit Name' => 'Yard', 'AllowPrefix' => False), 

    63. 

  63.             'ang' => array('Group' => 'Distance', 'Unit Name' => 'Angstrom', 'AllowPrefix' => True), 

    64. 

  64.             'Pica' => array('Group' => 'Distance', 'Unit Name' => 'Pica (1/72 in)', 'AllowPrefix' => False), 

    65. 

  65.             'yr' => array('Group' => 'Time', 'Unit Name' => 'Year', 'AllowPrefix' => False), 

    66. 

  66.             'day' => array('Group' => 'Time', 'Unit Name' => 'Day', 'AllowPrefix' => False), 

    67. 

  67.             'hr' => array('Group' => 'Time', 'Unit Name' => 'Hour', 'AllowPrefix' => False), 

    68. 

  68.             'mn' => array('Group' => 'Time', 'Unit Name' => 'Minute', 'AllowPrefix' => False), 

    69. 

  69.             'sec' => array('Group' => 'Time', 'Unit Name' => 'Second', 'AllowPrefix' => True), 

    70. 

  70.             'Pa' => array('Group' => 'Pressure', 'Unit Name' => 'Pascal', 'AllowPrefix' => True), 

    71. 

  71.             'p' => array('Group' => 'Pressure', 'Unit Name' => 'Pascal', 'AllowPrefix' => True), 

    72. 

  72.             'atm' => array('Group' => 'Pressure', 'Unit Name' => 'Atmosphere', 'AllowPrefix' => True), 

    73. 

  73.             'at' => array('Group' => 'Pressure', 'Unit Name' => 'Atmosphere', 'AllowPrefix' => True), 

    74. 

  74.             'mmHg' => array('Group' => 'Pressure', 'Unit Name' => 'mm of Mercury', 'AllowPrefix' => True), 

    75. 

  75.             'N' => array('Group' => 'Force', 'Unit Name' => 'Newton', 'AllowPrefix' => True), 

    76. 

  76.             'dyn' => array('Group' => 'Force', 'Unit Name' => 'Dyne', 'AllowPrefix' => True), 

    77. 

  77.             'dy' => array('Group' => 'Force', 'Unit Name' => 'Dyne', 'AllowPrefix' => True), 

    78. 

  78.             'lbf' => array('Group' => 'Force', 'Unit Name' => 'Pound force', 'AllowPrefix' => False), 

    79. 

  79.             'J' => array('Group' => 'Energy', 'Unit Name' => 'Joule', 'AllowPrefix' => True), 

    80. 

  80.             'e' => array('Group' => 'Energy', 'Unit Name' => 'Erg', 'AllowPrefix' => True), 

    81. 

  81.             'c' => array('Group' => 'Energy', 'Unit Name' => 'Thermodynamic calorie', 'AllowPrefix' => True), 

    82. 

  82.             'cal' => array('Group' => 'Energy', 'Unit Name' => 'IT calorie', 'AllowPrefix' => True), 

    83. 

  83.             'eV' => array('Group' => 'Energy', 'Unit Name' => 'Electron volt', 'AllowPrefix' => True), 

    84. 

  84.             'ev' => array('Group' => 'Energy', 'Unit Name' => 'Electron volt', 'AllowPrefix' => True), 

    85. 

  85.             'HPh' => array('Group' => 'Energy', 'Unit Name' => 'Horsepower-hour', 'AllowPrefix' => False), 

    86. 

  86.             'hh' => array('Group' => 'Energy', 'Unit Name' => 'Horsepower-hour', 'AllowPrefix' => False), 

    87. 

  87.             'Wh' => array('Group' => 'Energy', 'Unit Name' => 'Watt-hour', 'AllowPrefix' => True), 

    88. 

  88.             'wh' => array('Group' => 'Energy', 'Unit Name' => 'Watt-hour', 'AllowPrefix' => True), 

    89. 

  89.             'flb' => array('Group' => 'Energy', 'Unit Name' => 'Foot-pound', 'AllowPrefix' => False), 

    90. 

  90.             'BTU' => array('Group' => 'Energy', 'Unit Name' => 'BTU', 'AllowPrefix' => False), 

    91. 

  91.             'btu' => array('Group' => 'Energy', 'Unit Name' => 'BTU', 'AllowPrefix' => False), 

    92. 

  92.             'HP' => array('Group' => 'Power', 'Unit Name' => 'Horsepower', 'AllowPrefix' => False), 

    93. 

  93.             'h' => array('Group' => 'Power', 'Unit Name' => 'Horsepower', 'AllowPrefix' => False), 

    94. 

  94.             'W' => array('Group' => 'Power', 'Unit Name' => 'Watt', 'AllowPrefix' => True), 

    95. 

  95.             'w' => array('Group' => 'Power', 'Unit Name' => 'Watt', 'AllowPrefix' => True), 

    96. 

  96.             'T' => array('Group' => 'Magnetism', 'Unit Name' => 'Tesla', 'AllowPrefix' => True), 

    97. 

  97.             'ga' => array('Group' => 'Magnetism', 'Unit Name' => 'Gauss', 'AllowPrefix' => True), 

    98. 

  98.             'C' => array('Group' => 'Temperature', 'Unit Name' => 'Celsius', 'AllowPrefix' => False), 

    99. 

  99.             'cel' => array('Group' => 'Temperature', 'Unit Name' => 'Celsius', 'AllowPrefix' => False), 

    100. 

  100.             'F' => array('Group' => 'Temperature', 'Unit Name' => 'Fahrenheit', 'AllowPrefix' => False), 

    101. 

  101.             'fah' => array('Group' => 'Temperature', 'Unit Name' => 'Fahrenheit', 'AllowPrefix' => False), 

    102. 

  102.             'K' => array('Group' => 'Temperature', 'Unit Name' => 'Kelvin', 'AllowPrefix' => False), 

    103. 

  103.             'kel' => array('Group' => 'Temperature', 'Unit Name' => 'Kelvin', 'AllowPrefix' => False), 

    104. 

  104.             'tsp' => array('Group' => 'Liquid', 'Unit Name' => 'Teaspoon', 'AllowPrefix' => False), 

    105. 

  105.             'tbs' => array('Group' => 'Liquid', 'Unit Name' => 'Tablespoon', 'AllowPrefix' => False), 

    106. 

  106.             'oz' => array('Group' => 'Liquid', 'Unit Name' => 'Fluid Ounce', 'AllowPrefix' => False), 

    107. 

  107.             'cup' => array('Group' => 'Liquid', 'Unit Name' => 'Cup', 'AllowPrefix' => False), 

    108. 

  108.             'pt' => array('Group' => 'Liquid', 'Unit Name' => 'U.S. Pint', 'AllowPrefix' => False), 

    109. 

  109.             'us_pt' => array('Group' => 'Liquid', 'Unit Name' => 'U.S. Pint', 'AllowPrefix' => False), 

    110. 

  110.             'uk_pt' => array('Group' => 'Liquid', 'Unit Name' => 'U.K. Pint', 'AllowPrefix' => False), 

    111. 

  111.             'qt' => array('Group' => 'Liquid', 'Unit Name' => 'Quart', 'AllowPrefix' => False), 

    112. 

  112.             'gal' => array('Group' => 'Liquid', 'Unit Name' => 'Gallon', 'AllowPrefix' => False), 

    113. 

  113.             'l' => array('Group' => 'Liquid', 'Unit Name' => 'Litre', 'AllowPrefix' => True), 

    114. 

  114.             'lt' => array('Group' => 'Liquid', 'Unit Name' => 'Litre', 'AllowPrefix' => True));

    115. 

  115.     

    116. 

  116.     private static $_conversionMultipliers = array('Y' => array('multiplier' => 1E24, 'name' => 'yotta'), 

    117. 

  117.             'Z' => array('multiplier' => 1E21, 'name' => 'zetta'), 'E' => array('multiplier' => 1E18, 'name' => 'exa'), 

    118. 

  118.             'P' => array('multiplier' => 1E15, 'name' => 'peta'), 'T' => array('multiplier' => 1E12, 'name' => 'tera'), 

    119. 

  119.             'G' => array('multiplier' => 1E9, 'name' => 'giga'), 'M' => array('multiplier' => 1E6, 'name' => 'mega'), 

    120. 

  120.             'k' => array('multiplier' => 1E3, 'name' => 'kilo'), 'h' => array('multiplier' => 1E2, 'name' => 'hecto'), 

    121. 

  121.             'e' => array('multiplier' => 1E1, 'name' => 'deka'), 'd' => array('multiplier' => 1E-1, 'name' => 'deci'), 

    122. 

  122.             'c' => array('multiplier' => 1E-2, 'name' => 'centi'), 

    123. 

  123.             'm' => array('multiplier' => 1E-3, 'name' => 'milli'), 

    124. 

  124.             'u' => array('multiplier' => 1E-6, 'name' => 'micro'), 

    125. 

  125.             'n' => array('multiplier' => 1E-9, 'name' => 'nano'), 

    126. 

  126.             'p' => array('multiplier' => 1E-12, 'name' => 'pico'), 

    127. 

  127.             'f' => array('multiplier' => 1E-15, 'name' => 'femto'), 

    128. 

  128.             'a' => array('multiplier' => 1E-18, 'name' => 'atto'), 

    129. 

  129.             'z' => array('multiplier' => 1E-21, 'name' => 'zepto'), 

    130. 

  130.             'y' => array('multiplier' => 1E-24, 'name' => 'yocto'));

    131. 

  131.     

    132. 

  132.     private static $_unitConversions = array(

    133. 

  133.             'Mass' => array(

    134. 

  134.                     'g' => array('g' => 1.0, 'sg' => 6.85220500053478E-05, 'lbm' => 2.20462291469134E-03, 

    135. 

  135.                             'u' => 6.02217000000000E+23, 'ozm' => 3.52739718003627E-02), 

    136. 

  136.                     'sg' => array('g' => 1.45938424189287E+04, 'sg' => 1.0, 'lbm' => 3.21739194101647E+01, 

    137. 

  137.                             'u' => 8.78866000000000E+27, 'ozm' => 5.14782785944229E+02), 

    138. 

  138.                     'lbm' => array('g' => 4.5359230974881148E+02, 'sg' => 3.10810749306493E-02, 'lbm' => 1.0, 

    139. 

  139.                             'u' => 2.73161000000000E+26, 'ozm' => 1.60000023429410E+01), 

    140. 

  140.                     'u' => array('g' => 1.66053100460465E-24, 'sg' => 1.13782988532950E-28, 

    141. 

  141.                             'lbm' => 3.66084470330684E-27, 'u' => 1.0, 'ozm' => 5.85735238300524E-26), 

    142. 

  142.                     'ozm' => array('g' => 2.83495152079732E+01, 'sg' => 1.94256689870811E-03, 

    143. 

  143.                             'lbm' => 6.24999908478882E-02, 'u' => 1.70725600000000E+25, 'ozm' => 1.0)), 

    144. 

  144.             'Distance' => array(

    145. 

  145.                     'm' => array('m' => 1.0, 'mi' => 6.21371192237334E-04, 'Nmi' => 5.39956803455724E-04, 

    146. 

  146.                             'in' => 3.93700787401575E+01, 'ft' => 3.28083989501312E+00, 'yd' => 1.09361329797891E+00, 

    147. 

  147.                             'ang' => 1.00000000000000E+10, 'Pica' => 2.83464566929116E+03), 

    148. 

  148.                     'mi' => array('m' => 1.60934400000000E+03, 'mi' => 1.0, 'Nmi' => 8.68976241900648E-01, 

    149. 

  149.                             'in' => 6.33600000000000E+04, 'ft' => 5.28000000000000E+03, 'yd' => 1.76000000000000E+03, 

    150. 

  150.                             'ang' => 1.60934400000000E+13, 'Pica' => 4.56191999999971E+06), 

    151. 

  151.                     'Nmi' => array('m' => 1.85200000000000E+03, 'mi' => 1.15077944802354E+00, 'Nmi' => 1.0, 

    152. 

  152.                             'in' => 7.29133858267717E+04, 'ft' => 6.07611548556430E+03, 'yd' => 2.02537182785694E+03, 

    153. 

  153.                             'ang' => 1.85200000000000E+13, 'Pica' => 5.24976377952723E+06), 

    154. 

  154.                     'in' => array('m' => 2.54000000000000E-02, 'mi' => 1.57828282828283E-05, 

    155. 

  155.                             'Nmi' => 1.37149028077754E-05, 'in' => 1.0, 'ft' => 8.33333333333333E-02, 

    156. 

  156.                             'yd' => 2.77777777686643E-02, 'ang' => 2.54000000000000E+08, 'Pica' => 7.19999999999955E+01), 

    157. 

  157.                     'ft' => array('m' => 3.04800000000000E-01, 'mi' => 1.89393939393939E-04, 

    158. 

  158.                             'Nmi' => 1.64578833693305E-04, 'in' => 1.20000000000000E+01, 'ft' => 1.0, 

    159. 

  159.                             'yd' => 3.33333333223972E-01, 'ang' => 3.04800000000000E+09, 'Pica' => 8.63999999999946E+02), 

    160. 

  160.                     'yd' => array('m' => 9.14400000300000E-01, 'mi' => 5.68181818368230E-04, 

    161. 

  161.                             'Nmi' => 4.93736501241901E-04, 'in' => 3.60000000118110E+01, 'ft' => 3.00000000000000E+00, 

    162. 

  162.                             'yd' => 1.0, 'ang' => 9.14400000300000E+09, 'Pica' => 2.59200000085023E+03), 

    163. 

  163.                     'ang' => array('m' => 1.00000000000000E-10, 'mi' => 6.21371192237334E-14, 

    164. 

  164.                             'Nmi' => 5.39956803455724E-14, 'in' => 3.93700787401575E-09, 'ft' => 3.28083989501312E-10, 

    165. 

  165.                             'yd' => 1.09361329797891E-10, 'ang' => 1.0, 'Pica' => 2.83464566929116E-07), 

    166. 

  166.                     'Pica' => array('m' => 3.52777777777800E-04, 'mi' => 2.19205948372629E-07, 

    167. 

  167.                             'Nmi' => 1.90484761219114E-07, 'in' => 1.38888888888898E-02, 'ft' => 1.15740740740748E-03, 

    168. 

  168.                             'yd' => 3.85802469009251E-04, 'ang' => 3.52777777777800E+06, 'Pica' => 1.0)), 

    169. 

  169.             'Time' => array(

    170. 

  170.                     'yr' => array('yr' => 1.0, 'day' => 365.25, 'hr' => 8766.0, 'mn' => 525960.0, 'sec' => 31557600.0), 

    171. 

  171.                     'day' => array('yr' => 2.73785078713210E-03, 'day' => 1.0, 'hr' => 24.0, 'mn' => 1440.0, 

    172. 

  172.                             'sec' => 86400.0), 

    173. 

  173.                     'hr' => array('yr' => 1.14077116130504E-04, 'day' => 4.16666666666667E-02, 'hr' => 1.0, 

    174. 

  174.                             'mn' => 60.0, 'sec' => 3600.0), 

    175. 

  175.                     'mn' => array('yr' => 1.90128526884174E-06, 'day' => 6.94444444444444E-04, 

    176. 

  176.                             'hr' => 1.66666666666667E-02, 'mn' => 1.0, 'sec' => 60.0), 

    177. 

  177.                     'sec' => array('yr' => 3.16880878140289E-08, 'day' => 1.15740740740741E-05, 

    178. 

  178.                             'hr' => 2.77777777777778E-04, 'mn' => 1.66666666666667E-02, 'sec' => 1.0)), 

    179. 

  179.             'Pressure' => array(

    180. 

  180.                     'Pa' => array('Pa' => 1.0, 'p' => 1.0, 'atm' => 9.86923299998193E-06, 'at' => 9.86923299998193E-06, 

    181. 

  181.                             'mmHg' => 7.50061707998627E-03), 

    182. 

  182.                     'p' => array('Pa' => 1.0, 'p' => 1.0, 'atm' => 9.86923299998193E-06, 'at' => 9.86923299998193E-06, 

    183. 

  183.                             'mmHg' => 7.50061707998627E-03), 

    184. 

  184.                     'atm' => array('Pa' => 1.01324996583000E+05, 'p' => 1.01324996583000E+05, 'atm' => 1.0, 

    185. 

  185.                             'at' => 1.0, 'mmHg' => 760.0), 

    186. 

  186.                     'at' => array('Pa' => 1.01324996583000E+05, 'p' => 1.01324996583000E+05, 'atm' => 1.0, 'at' => 1.0, 

    187. 

  187.                             'mmHg' => 760.0), 

    188. 

  188.                     'mmHg' => array('Pa' => 1.33322363925000E+02, 'p' => 1.33322363925000E+02, 

    189. 

  189.                             'atm' => 1.31578947368421E-03, 'at' => 1.31578947368421E-03, 'mmHg' => 1.0)), 

    190. 

  190.             'Force' => array(

    191. 

  191.                     'N' => array('N' => 1.0, 'dyn' => 1.0E+5, 'dy' => 1.0E+5, 'lbf' => 2.24808923655339E-01), 

    192. 

  192.                     'dyn' => array('N' => 1.0E-5, 'dyn' => 1.0, 'dy' => 1.0, 'lbf' => 2.24808923655339E-06), 

    193. 

  193.                     'dy' => array('N' => 1.0E-5, 'dyn' => 1.0, 'dy' => 1.0, 'lbf' => 2.24808923655339E-06), 

    194. 

  194.                     'lbf' => array('N' => 4.448222, 'dyn' => 4.448222E+5, 'dy' => 4.448222E+5, 'lbf' => 1.0)), 

    195. 

  195.             'Energy' => array(

    196. 

  196.                     'J' => array('J' => 1.0, 'e' => 9.99999519343231E+06, 'c' => 2.39006249473467E-01, 

    197. 

  197.                             'cal' => 2.38846190642017E-01, 'eV' => 6.24145700000000E+18, 'ev' => 6.24145700000000E+18, 

    198. 

  198.                             'HPh' => 3.72506430801000E-07, 'hh' => 3.72506430801000E-07, 'Wh' => 2.77777916238711E-04, 

    199. 

  199.                             'wh' => 2.77777916238711E-04, 'flb' => 2.37304222192651E+01, 'BTU' => 9.47815067349015E-04, 

    200. 

  200.                             'btu' => 9.47815067349015E-04), 

    201. 

  201.                     'e' => array('J' => 1.00000048065700E-07, 'e' => 1.0, 'c' => 2.39006364353494E-08, 

    202. 

  202.                             'cal' => 2.38846305445111E-08, 'eV' => 6.24146000000000E+11, 'ev' => 6.24146000000000E+11, 

    203. 

  203.                             'HPh' => 3.72506609848824E-14, 'hh' => 3.72506609848824E-14, 'Wh' => 2.77778049754611E-11, 

    204. 

  204.                             'wh' => 2.77778049754611E-11, 'flb' => 2.37304336254586E-06, 'BTU' => 9.47815522922962E-11, 

    205. 

  205.                             'btu' => 9.47815522922962E-11), 

    206. 

  206.                     'c' => array('J' => 4.18399101363672E+00, 'e' => 4.18398900257312E+07, 'c' => 1.0, 

    207. 

  207.                             'cal' => 9.99330315287563E-01, 'eV' => 2.61142000000000E+19, 'ev' => 2.61142000000000E+19, 

    208. 

  208.                             'HPh' => 1.55856355899327E-06, 'hh' => 1.55856355899327E-06, 'Wh' => 1.16222030532950E-03, 

    209. 

  209.                             'wh' => 1.16222030532950E-03, 'flb' => 9.92878733152102E+01, 'BTU' => 3.96564972437776E-03, 

    210. 

  210.                             'btu' => 3.96564972437776E-03), 

    211. 

  211.                     'cal' => array('J' => 4.18679484613929E+00, 'e' => 4.18679283372801E+07, 

    212. 

  212.                             'c' => 1.00067013349059E+00, 'cal' => 1.0, 'eV' => 2.61317000000000E+19, 

    213. 

  213.                             'ev' => 2.61317000000000E+19, 'HPh' => 1.55960800463137E-06, 'hh' => 1.55960800463137E-06, 

    214. 

  214.                             'Wh' => 1.16299914807955E-03, 'wh' => 1.16299914807955E-03, 'flb' => 9.93544094443283E+01, 

    215. 

  215.                             'BTU' => 3.96830723907002E-03, 'btu' => 3.96830723907002E-03), 

    216. 

  216.                     'eV' => array('J' => 1.60219000146921E-19, 'e' => 1.60218923136574E-12, 

    217. 

  217.                             'c' => 3.82933423195043E-20, 'cal' => 3.82676978535648E-20, 'eV' => 1.0, 'ev' => 1.0, 

    218. 

  218.                             'HPh' => 5.96826078912344E-26, 'hh' => 5.96826078912344E-26, 'Wh' => 4.45053000026614E-23, 

    219. 

  219.                             'wh' => 4.45053000026614E-23, 'flb' => 3.80206452103492E-18, 'BTU' => 1.51857982414846E-22, 

    220. 

  220.                             'btu' => 1.51857982414846E-22), 

    221. 

  221.                     'ev' => array('J' => 1.60219000146921E-19, 'e' => 1.60218923136574E-12, 

    222. 

  222.                             'c' => 3.82933423195043E-20, 'cal' => 3.82676978535648E-20, 'eV' => 1.0, 'ev' => 1.0, 

    223. 

  223.                             'HPh' => 5.96826078912344E-26, 'hh' => 5.96826078912344E-26, 'Wh' => 4.45053000026614E-23, 

    224. 

  224.                             'wh' => 4.45053000026614E-23, 'flb' => 3.80206452103492E-18, 'BTU' => 1.51857982414846E-22, 

    225. 

  225.                             'btu' => 1.51857982414846E-22), 

    226. 

  226.                     'HPh' => array('J' => 2.68451741316170E+06, 'e' => 2.68451612283024E+13, 

    227. 

  227.                             'c' => 6.41616438565991E+05, 'cal' => 6.41186757845835E+05, 'eV' => 1.67553000000000E+25, 

    228. 

  228.                             'ev' => 1.67553000000000E+25, 'HPh' => 1.0, 'hh' => 1.0, 'Wh' => 7.45699653134593E+02, 

    229. 

  229.                             'wh' => 7.45699653134593E+02, 'flb' => 6.37047316692964E+07, 'BTU' => 2.54442605275546E+03, 

    230. 

  230.                             'btu' => 2.54442605275546E+03), 

    231. 

  231.                     'hh' => array('J' => 2.68451741316170E+06, 'e' => 2.68451612283024E+13, 

    232. 

  232.                             'c' => 6.41616438565991E+05, 'cal' => 6.41186757845835E+05, 'eV' => 1.67553000000000E+25, 

    233. 

  233.                             'ev' => 1.67553000000000E+25, 'HPh' => 1.0, 'hh' => 1.0, 'Wh' => 7.45699653134593E+02, 

    234. 

  234.                             'wh' => 7.45699653134593E+02, 'flb' => 6.37047316692964E+07, 'BTU' => 2.54442605275546E+03, 

    235. 

  235.                             'btu' => 2.54442605275546E+03), 

    236. 

  236.                     'Wh' => array('J' => 3.59999820554720E+03, 'e' => 3.59999647518369E+10, 

    237. 

  237.                             'c' => 8.60422069219046E+02, 'cal' => 8.59845857713046E+02, 'eV' => 2.24692340000000E+22, 

    238. 

  238.                             'ev' => 2.24692340000000E+22, 'HPh' => 1.34102248243839E-03, 'hh' => 1.34102248243839E-03, 

    239. 

  239.                             'Wh' => 1.0, 'wh' => 1.0, 'flb' => 8.54294774062316E+04, 'BTU' => 3.41213254164705E+00, 

    240. 

  240.                             'btu' => 3.41213254164705E+00), 

    241. 

  241.                     'wh' => array('J' => 3.59999820554720E+03, 'e' => 3.59999647518369E+10, 

    242. 

  242.                             'c' => 8.60422069219046E+02, 'cal' => 8.59845857713046E+02, 'eV' => 2.24692340000000E+22, 

    243. 

  243.                             'ev' => 2.24692340000000E+22, 'HPh' => 1.34102248243839E-03, 'hh' => 1.34102248243839E-03, 

    244. 

  244.                             'Wh' => 1.0, 'wh' => 1.0, 'flb' => 8.54294774062316E+04, 'BTU' => 3.41213254164705E+00, 

    245. 

  245.                             'btu' => 3.41213254164705E+00), 

    246. 

  246.                     'flb' => array('J' => 4.21400003236424E-02, 'e' => 4.21399800687660E+05, 

    247. 

  247.                             'c' => 1.00717234301644E-02, 'cal' => 1.00649785509554E-02, 'eV' => 2.63015000000000E+17, 

    248. 

  248.                             'ev' => 2.63015000000000E+17, 'HPh' => 1.56974211145130E-08, 'hh' => 1.56974211145130E-08, 

    249. 

  249.                             'Wh' => 1.17055614802000E-05, 'wh' => 1.17055614802000E-05, 'flb' => 1.0, 

    250. 

  250.                             'BTU' => 3.99409272448406E-05, 'btu' => 3.99409272448406E-05), 

    251. 

  251.                     'BTU' => array('J' => 1.05505813786749E+03, 'e' => 1.05505763074665E+10, 

    252. 

  252.                             'c' => 2.52165488508168E+02, 'cal' => 2.51996617135510E+02, 'eV' => 6.58510000000000E+21, 

    253. 

  253.                             'ev' => 6.58510000000000E+21, 'HPh' => 3.93015941224568E-04, 'hh' => 3.93015941224568E-04, 

    254. 

  254.                             'Wh' => 2.93071851047526E-01, 'wh' => 2.93071851047526E-01, 'flb' => 2.50369750774671E+04, 

    255. 

  255.                             'BTU' => 1.0, 'btu' => 1.0), 

    256. 

  256.                     'btu' => array('J' => 1.05505813786749E+03, 'e' => 1.05505763074665E+10, 

    257. 

  257.                             'c' => 2.52165488508168E+02, 'cal' => 2.51996617135510E+02, 'eV' => 6.58510000000000E+21, 

    258. 

  258.                             'ev' => 6.58510000000000E+21, 'HPh' => 3.93015941224568E-04, 'hh' => 3.93015941224568E-04, 

    259. 

  259.                             'Wh' => 2.93071851047526E-01, 'wh' => 2.93071851047526E-01, 'flb' => 2.50369750774671E+04, 

    260. 

  260.                             'BTU' => 1.0, 'btu' => 1.0)), 

    261. 

  261.             'Power' => array(

    262. 

  262.                     'HP' => array('HP' => 1.0, 'h' => 1.0, 'W' => 7.45701000000000E+02, 'w' => 7.45701000000000E+02), 

    263. 

  263.                     'h' => array('HP' => 1.0, 'h' => 1.0, 'W' => 7.45701000000000E+02, 'w' => 7.45701000000000E+02), 

    264. 

  264.                     'W' => array('HP' => 1.34102006031908E-03, 'h' => 1.34102006031908E-03, 'W' => 1.0, 'w' => 1.0), 

    265. 

  265.                     'w' => array('HP' => 1.34102006031908E-03, 'h' => 1.34102006031908E-03, 'W' => 1.0, 'w' => 1.0)), 

    266. 

  266.             'Magnetism' => array(

    267. 

  267.                     'T' => array('T' => 1.0, 'ga' => 10000.0), 

    268. 

  268.                     'ga' => array('T' => 0.0001, 'ga' => 1.0)), 

    269. 

  269.             'Liquid' => array(

    270. 

  270.                     'tsp' => array('tsp' => 1.0, 'tbs' => 3.33333333333333E-01, 'oz' => 1.66666666666667E-01, 

    271. 

  271.                             'cup' => 2.08333333333333E-02, 'pt' => 1.04166666666667E-02, 

    272. 

  272.                             'us_pt' => 1.04166666666667E-02, 'uk_pt' => 8.67558516821960E-03, 

    273. 

  273.                             'qt' => 5.20833333333333E-03, 'gal' => 1.30208333333333E-03, 'l' => 4.92999408400710E-03, 

    274. 

  274.                             'lt' => 4.92999408400710E-03), 

    275. 

  275.                     'tbs' => array('tsp' => 3.00000000000000E+00, 'tbs' => 1.0, 'oz' => 5.00000000000000E-01, 

    276. 

  276.                             'cup' => 6.25000000000000E-02, 'pt' => 3.12500000000000E-02, 

    277. 

  277.                             'us_pt' => 3.12500000000000E-02, 'uk_pt' => 2.60267555046588E-02, 

    278. 

  278.                             'qt' => 1.56250000000000E-02, 'gal' => 3.90625000000000E-03, 'l' => 1.47899822520213E-02, 

    279. 

  279.                             'lt' => 1.47899822520213E-02), 

    280. 

  280.                     'oz' => array('tsp' => 6.00000000000000E+00, 'tbs' => 2.00000000000000E+00, 'oz' => 1.0, 

    281. 

  281.                             'cup' => 1.25000000000000E-01, 'pt' => 6.25000000000000E-02, 

    282. 

  282.                             'us_pt' => 6.25000000000000E-02, 'uk_pt' => 5.20535110093176E-02, 

    283. 

  283.                             'qt' => 3.12500000000000E-02, 'gal' => 7.81250000000000E-03, 'l' => 2.95799645040426E-02, 

    284. 

  284.                             'lt' => 2.95799645040426E-02), 

    285. 

  285.                     'cup' => array('tsp' => 4.80000000000000E+01, 'tbs' => 1.60000000000000E+01, 

    286. 

  286.                             'oz' => 8.00000000000000E+00, 'cup' => 1.0, 'pt' => 5.00000000000000E-01, 

    287. 

  287.                             'us_pt' => 5.00000000000000E-01, 'uk_pt' => 4.16428088074541E-01, 

    288. 

  288.                             'qt' => 2.50000000000000E-01, 'gal' => 6.25000000000000E-02, 'l' => 2.36639716032341E-01, 

    289. 

  289.                             'lt' => 2.36639716032341E-01), 

    290. 

  290.                     'pt' => array('tsp' => 9.60000000000000E+01, 'tbs' => 3.20000000000000E+01, 

    291. 

  291.                             'oz' => 1.60000000000000E+01, 'cup' => 2.00000000000000E+00, 'pt' => 1.0, 'us_pt' => 1.0, 

    292. 

  292.                             'uk_pt' => 8.32856176149081E-01, 'qt' => 5.00000000000000E-01, 

    293. 

  293.                             'gal' => 1.25000000000000E-01, 'l' => 4.73279432064682E-01, 'lt' => 4.73279432064682E-01), 

    294. 

  294.                     'us_pt' => array('tsp' => 9.60000000000000E+01, 'tbs' => 3.20000000000000E+01, 

    295. 

  295.                             'oz' => 1.60000000000000E+01, 'cup' => 2.00000000000000E+00, 'pt' => 1.0, 'us_pt' => 1.0, 

    296. 

  296.                             'uk_pt' => 8.32856176149081E-01, 'qt' => 5.00000000000000E-01, 

    297. 

  297.                             'gal' => 1.25000000000000E-01, 'l' => 4.73279432064682E-01, 'lt' => 4.73279432064682E-01), 

    298. 

  298.                     'uk_pt' => array('tsp' => 1.15266000000000E+02, 'tbs' => 3.84220000000000E+01, 

    299. 

  299.                             'oz' => 1.92110000000000E+01, 'cup' => 2.40137500000000E+00, 'pt' => 1.20068750000000E+00, 

    300. 

  300.                             'us_pt' => 1.20068750000000E+00, 'uk_pt' => 1.0, 'qt' => 6.00343750000000E-01, 

    301. 

  301.                             'gal' => 1.50085937500000E-01, 'l' => 5.68260698087162E-01, 'lt' => 5.68260698087162E-01), 

    302. 

  302.                     'qt' => array('tsp' => 1.92000000000000E+02, 'tbs' => 6.40000000000000E+01, 

    303. 

  303.                             'oz' => 3.20000000000000E+01, 'cup' => 4.00000000000000E+00, 'pt' => 2.00000000000000E+00, 

    304. 

  304.                             'us_pt' => 2.00000000000000E+00, 'uk_pt' => 1.66571235229816E+00, 'qt' => 1.0, 

    305. 

  305.                             'gal' => 2.50000000000000E-01, 'l' => 9.46558864129363E-01, 'lt' => 9.46558864129363E-01), 

    306. 

  306.                     'gal' => array('tsp' => 7.68000000000000E+02, 'tbs' => 2.56000000000000E+02, 

    307. 

  307.                             'oz' => 1.28000000000000E+02, 'cup' => 1.60000000000000E+01, 'pt' => 8.00000000000000E+00, 

    308. 

  308.                             'us_pt' => 8.00000000000000E+00, 'uk_pt' => 6.66284940919265E+00, 

    309. 

  309.                             'qt' => 4.00000000000000E+00, 'gal' => 1.0, 'l' => 3.78623545651745E+00, 

    310. 

  310.                             'lt' => 3.78623545651745E+00), 

    311. 

  311.                     'l' => array('tsp' => 2.02840000000000E+02, 'tbs' => 6.76133333333333E+01, 

    312. 

  312.                             'oz' => 3.38066666666667E+01, 'cup' => 4.22583333333333E+00, 'pt' => 2.11291666666667E+00, 

    313. 

  313.                             'us_pt' => 2.11291666666667E+00, 'uk_pt' => 1.75975569552166E+00, 

    314. 

  314.                             'qt' => 1.05645833333333E+00, 'gal' => 2.64114583333333E-01, 'l' => 1.0, 'lt' => 1.0), 

    315. 

  315.                     'lt' => array('tsp' => 2.02840000000000E+02, 'tbs' => 6.76133333333333E+01, 

    316. 

  316.                             'oz' => 3.38066666666667E+01, 'cup' => 4.22583333333333E+00, 'pt' => 2.11291666666667E+00, 

    317. 

  317.                             'us_pt' => 2.11291666666667E+00, 'uk_pt' => 1.75975569552166E+00, 

    318. 

  318.                             'qt' => 1.05645833333333E+00, 'gal' => 2.64114583333333E-01, 'l' => 1.0, 'lt' => 1.0)));

    319. 

  319. 

    320. 

  320.     public static function _parseComplex($complexNumber)

    321. 

  321.     {

    322. 

  322.         $workString = (string) $complexNumber;

    323. 

  323.         

    324. 

  324.         $realNumber = $imaginary = 0;

    325. 

  325.         //	Extract the suffix, if there is one
    326. 

  326.         $suffix = substr($workString, - 1);

    327. 

  327.         if (! is_numeric($suffix))

    328. 

  328.         {

    329. 

  329.             $workString = substr($workString, 0, - 1);

    330. 

  330.         }

    331. 

  331.         else

    332. 

  332.         {

    333. 

  333.             $suffix = '';

    334. 

  334.         }

    335. 

  335.         

    336. 

  336.         //	Split the input into its Real and Imaginary components
    337. 

  337.         $leadingSign = 0;

    338. 

  338.         if (strlen($workString) > 0)

    339. 

  339.         {

    340. 

  340.             $leadingSign = (($workString{0} == '+') || ($workString{0} == '-')) ? 1 : 0;

    341. 

  341.         }

    342. 

  342.         $power = '';

    343. 

  343.         $realNumber = strtok($workString, '+-');

    344. 

  344.         if (strtoupper(substr($realNumber, - 1)) == 'E')

    345. 

  345.         {

    346. 

  346.             $power = strtok('+-');

    347. 

  347.             ++ $leadingSign;

    348. 

  348.         }

    349. 

  349.         

    350. 

  350.         $realNumber = substr($workString, 0, strlen($realNumber) + strlen($power) + $leadingSign);

    351. 

  351.         

    352. 

  352.         if ($suffix != '')

    353. 

  353.         {

    354. 

  354.             $imaginary = substr($workString, strlen($realNumber));

    355. 

  355.             

    356. 

  356.             if (($imaginary == '') && (($realNumber == '') || ($realNumber == '+') || ($realNumber == '-')))

    357. 

  357.             {

    358. 

  358.                 $imaginary = $realNumber . '1';

    359. 

  359.                 $realNumber = '0';

    360. 

  360.             }

    361. 

  361.             else 

    362. 

  362.                 if ($imaginary == '')

    363. 

  363.                 {

    364. 

  364.                     $imaginary = $realNumber;

    365. 

  365.                     $realNumber = '0';

    366. 

  366.                 }

    367. 

  367.                 elseif (($imaginary == '+') || ($imaginary == '-'))

    368. 

  368.                 {

    369. 

  369.                     $imaginary .= '1';

    370. 

  370.                 }

    371. 

  371.         }

    372. 

  372.         

    373. 

  373.         return array('real' => $realNumber, 'imaginary' => $imaginary, 'suffix' => $suffix);

    374. 

  374.     } //	function _parseComplex()
    375. 

  375. 

    376. 

  376.     

    377. 

  377.     private static function _cleanComplex($complexNumber)

    378. 

  378.     {

    379. 

  379.         if ($complexNumber{0} == '+')

    380. 

  380.             $complexNumber = substr($complexNumber, 1);

    381. 

  381.         if ($complexNumber{0} == '0')

    382. 

  382.             $complexNumber = substr($complexNumber, 1);

    383. 

  383.         if ($complexNumber{0} == '.')

    384. 

  384.             $complexNumber = '0' . $complexNumber;

    385. 

  385.         if ($complexNumber{0} == '+')

    386. 

  386.             $complexNumber = substr($complexNumber, 1);

    387. 

  387.         return $complexNumber;

    388. 

  388.     }

    389. 

  389. 

    390. 

  390.     private static function _nbrConversionFormat($xVal, $places)

    391. 

  391.     {

    392. 

  392.         if (! is_null($places))

    393. 

  393.         {

    394. 

  394.             if (strlen($xVal) <= $places)

    395. 

  395.             {

    396. 

  396.                 return substr(str_pad($xVal, $places, '0', STR_PAD_LEFT), - 10);

    397. 

  397.             }

    398. 

  398.             else

    399. 

  399.             {

    400. 

  400.                 return PHPExcel_Calculation_Functions :: NaN();

    401. 

  401.             }

    402. 

  402.         }

    403. 

  403.         

    404. 

  404.         return substr($xVal, - 10);

    405. 

  405.     } //	function _nbrConversionFormat()
    406. 

  406. 

    407. 

  407.     

    408. 

  408.     /**
    409. 

  409.      * BESSELI
    410. 

  410.      *
    411. 

  411.      * Returns the modified Bessel function, which is equivalent to the Bessel function evaluated for purely imaginary arguments
    412. 

  412.      *
    413. 

  413.      * @param	float		$x
    414. 

  414.      * @param	float		$n
    415. 

  415.      * @return	int
    416. 

  416.      */

    417. 

  417.     public static function BESSELI($x, $n)

    418. 

  418.     {

    419. 

  419.         $x = (is_null($x)) ? 0.0 : PHPExcel_Calculation_Functions :: flattenSingleValue($x);

    420. 

  420.         $n = (is_null($n)) ? 0.0 : PHPExcel_Calculation_Functions :: flattenSingleValue($n);

    421. 

  421.         

    422. 

  422.         if ((is_numeric($x)) && (is_numeric($n)))

    423. 

  423.         {

    424. 

  424.             $n = floor($n);

    425. 

  425.             if ($n < 0)

    426. 

  426.             {

    427. 

  427.                 return PHPExcel_Calculation_Functions :: NaN();

    428. 

  428.             }

    429. 

  429.             $f_2_PI = 2 * M_PI;

    430. 

  430.             

    431. 

  431.             if (abs($x) <= 30)

    432. 

  432.             {

    433. 

  433.                 $fTerm = pow($x / 2, $n) / PHPExcel_Calculation_MathTrig :: FACT($n);

    434. 

  434.                 $nK = 1;

    435. 

  435.                 $fResult = $fTerm;

    436. 

  436.                 $fSqrX = ($x * $x) / 4;

    437. 

  437.                 do

    438. 

  438.                 {

    439. 

  439.                     $fTerm *= $fSqrX;

    440. 

  440.                     $fTerm /= ($nK * ($nK + $n));

    441. 

  441.                     $fResult += $fTerm;

    442. 

  442.                 }

    443. 

  443.                 while ((abs($fTerm) > 1e-10) && (++ $nK < 100));

    444. 

  444.             }

    445. 

  445.             else

    446. 

  446.             {

    447. 

  447.                 $fXAbs = abs($x);

    448. 

  448.                 $fResult = exp($fXAbs) / sqrt($f_2_PI * $fXAbs);

    449. 

  449.                 if (($n && 1) && ($x < 0))

    450. 

  450.                 {

    451. 

  451.                     $fResult = - $fResult;

    452. 

  452.                 }

    453. 

  453.             }

    454. 

  454.             return $fResult;

    455. 

  455.         }

    456. 

  456.         return PHPExcel_Calculation_Functions :: VALUE();

    457. 

  457.     } //	function BESSELI()
    458. 

  458. 

    459. 

  459.     

    460. 

  460.     /**
    461. 

  461.      * BESSELJ
    462. 

  462.      *
    463. 

  463.      * Returns the Bessel function
    464. 

  464.      *
    465. 

  465.      * @param	float		$x
    466. 

  466.      * @param	float		$n
    467. 

  467.      * @return	int
    468. 

  468.      */

    469. 

  469.     public static function BESSELJ($x, $n)

    470. 

  470.     {

    471. 

  471.         $x = (is_null($x)) ? 0.0 : PHPExcel_Calculation_Functions :: flattenSingleValue($x);

    472. 

  472.         $n = (is_null($n)) ? 0.0 : PHPExcel_Calculation_Functions :: flattenSingleValue($n);

    473. 

  473.         

    474. 

  474.         if ((is_numeric($x)) && (is_numeric($n)))

    475. 

  475.         {

    476. 

  476.             $n = floor($n);

    477. 

  477.             if ($n < 0)

    478. 

  478.             {

    479. 

  479.                 return PHPExcel_Calculation_Functions :: NaN();

    480. 

  480.             }

    481. 

  481.             $f_PI_DIV_2 = M_PI / 2;

    482. 

  482.             $f_PI_DIV_4 = M_PI / 4;

    483. 

  483.             

    484. 

  484.             $fResult = 0;

    485. 

  485.             if (abs($x) <= 30)

    486. 

  486.             {

    487. 

  487.                 $fTerm = pow($x / 2, $n) / PHPExcel_Calculation_MathTrig :: FACT($n);

    488. 

  488.                 $nK = 1;

    489. 

  489.                 $fResult = $fTerm;

    490. 

  490.                 $fSqrX = ($x * $x) / - 4;

    491. 

  491.                 do

    492. 

  492.                 {

    493. 

  493.                     $fTerm *= $fSqrX;

    494. 

  494.                     $fTerm /= ($nK * ($nK + $n));

    495. 

  495.                     $fResult += $fTerm;

    496. 

  496.                 }

    497. 

  497.                 while ((abs($fTerm) > 1e-10) && (++ $nK < 100));

    498. 

  498.             }

    499. 

  499.             else

    500. 

  500.             {

    501. 

  501.                 $fXAbs = abs($x);

    502. 

  502.                 $fResult = sqrt(M_2DIVPI / $fXAbs) * cos($fXAbs - $n * $f_PI_DIV_2 - $f_PI_DIV_4);

    503. 

  503.                 if (($n && 1) && ($x < 0))

    504. 

  504.                 {

    505. 

  505.                     $fResult = - $fResult;

    506. 

  506.                 }

    507. 

  507.             }

    508. 

  508.             return $fResult;

    509. 

  509.         }

    510. 

  510.         return PHPExcel_Calculation_Functions :: VALUE();

    511. 

  511.     } //	function BESSELJ()
    512. 

  512. 

    513. 

  513.     

    514. 

  514.     private static function _Besselk0($fNum)

    515. 

  515.     {

    516. 

  516.         if ($fNum <= 2)

    517. 

  517.         {

    518. 

  518.             $fNum2 = $fNum * 0.5;

    519. 

  519.             $y = ($fNum2 * $fNum2);

    520. 

  520.             $fRet = - log($fNum2) * self :: BESSELI($fNum, 0) + (- 0.57721566 + $y * (0.42278420 + $y * (0.23069756 + $y * (0.3488590e-1 + $y * (0.262698e-2 + $y * (0.10750e-3 + $y * 0.74e-5))))));

    521. 

  521.         }

    522. 

  522.         else

    523. 

  523.         {

    524. 

  524.             $y = 2 / $fNum;

    525. 

  525.             $fRet = exp(- $fNum) / sqrt($fNum) * (1.25331414 + $y * (- 0.7832358e-1 + $y * (0.2189568e-1 + $y * (- 0.1062446e-1 + $y * (0.587872e-2 + $y * (- 0.251540e-2 + $y * 0.53208e-3))))));

    526. 

  526.         }

    527. 

  527.         return $fRet;

    528. 

  528.     } //	function _Besselk0()
    529. 

  529. 

    530. 

  530.     

    531. 

  531.     private static function _Besselk1($fNum)

    532. 

  532.     {

    533. 

  533.         if ($fNum <= 2)

    534. 

  534.         {

    535. 

  535.             $fNum2 = $fNum * 0.5;

    536. 

  536.             $y = ($fNum2 * $fNum2);

    537. 

  537.             $fRet = log($fNum2) * self :: BESSELI($fNum, 1) + (1 + $y * (0.15443144 + $y * (- 0.67278579 + $y * (- 0.18156897 + $y * (- 0.1919402e-1 + $y * (- 0.110404e-2 + $y * (- 0.4686e-4))))))) / $fNum;

    538. 

  538.         }

    539. 

  539.         else

    540. 

  540.         {

    541. 

  541.             $y = 2 / $fNum;

    542. 

  542.             $fRet = exp(- $fNum) / sqrt($fNum) * (1.25331414 + $y * (0.23498619 + $y * (- 0.3655620e-1 + $y * (0.1504268e-1 + $y * (- 0.780353e-2 + $y * (0.325614e-2 + $y * (- 0.68245e-3)))))));

    543. 

  543.         }

    544. 

  544.         return $fRet;

    545. 

  545.     } //	function _Besselk1()
    546. 

  546. 

    547. 

  547.     

    548. 

  548.     /**
    549. 

  549.      * BESSELK
    550. 

  550.      *
    551. 

  551.      * Returns the modified Bessel function, which is equivalent to the Bessel functions evaluated for purely imaginary arguments.
    552. 

  552.      *
    553. 

  553.      * @param	float		$x
    554. 

  554.      * @param	float		$ord
    555. 

  555.      * @return	float
    556. 

  556.      */

    557. 

  557.     public static function BESSELK($x, $ord)

    558. 

  558.     {

    559. 

  559.         $x = (is_null($x)) ? 0.0 : PHPExcel_Calculation_Functions :: flattenSingleValue($x);

    560. 

  560.         $ord = (is_null($ord)) ? 0.0 : PHPExcel_Calculation_Functions :: flattenSingleValue($ord);

    561. 

  561.         

    562. 

  562.         if ((is_numeric($x)) && (is_numeric($ord)))

    563. 

  563.         {

    564. 

  564.             if (($ord < 0) || ($x == 0.0))

    565. 

  565.             {

    566. 

  566.                 return PHPExcel_Calculation_Functions :: NaN();

    567. 

  567.             }

    568. 

  568.             

    569. 

  569.             switch (floor($ord))

    570. 

  570.             {

    571. 

  571.                 case 0 :

    572. 

  572.                     return self :: _Besselk0($x);

    573. 

  573.                     break;

    574. 

  574.                 case 1 :

    575. 

  575.                     return self :: _Besselk1($x);

    576. 

  576.                     break;

    577. 

  577.                 default :

    578. 

  578.                     $fTox = 2 / $x;

    579. 

  579.                     $fBkm = self :: _Besselk0($x);

    580. 

  580.                     $fBk = self :: _Besselk1($x);

    581. 

  581.                     for($n = 1; $n < $ord; ++ $n)

    582. 

  582.                     {

    583. 

  583.                         $fBkp = $fBkm + $n * $fTox * $fBk;

    584. 

  584.                         $fBkm = $fBk;

    585. 

  585.                         $fBk = $fBkp;

    586. 

  586.                     }

    587. 

  587.             }

    588. 

  588.             return $fBk;

    589. 

  589.         }

    590. 

  590.         return PHPExcel_Calculation_Functions :: VALUE();

    591. 

  591.     } //	function BESSELK()
    592. 

  592. 

    593. 

  593.     

    594. 

  594.     private static function _Bessely0($fNum)

    595. 

  595.     {

    596. 

  596.         if ($fNum < 8.0)

    597. 

  597.         {

    598. 

  598.             $y = ($fNum * $fNum);

    599. 

  599.             $f1 = - 2957821389.0 + $y * (7062834065.0 + $y * (- 512359803.6 + $y * (10879881.29 + $y * (- 86327.92757 + $y * 228.4622733))));

    600. 

  600.             $f2 = 40076544269.0 + $y * (745249964.8 + $y * (7189466.438 + $y * (47447.26470 + $y * (226.1030244 + $y))));

    601. 

  601.             $fRet = $f1 / $f2 + M_2DIVPI * self :: BESSELJ($fNum, 0) * log($fNum);

    602. 

  602.         }

    603. 

  603.         else

    604. 

  604.         {

    605. 

  605.             $z = 8.0 / $fNum;

    606. 

  606.             $y = ($z * $z);

    607. 

  607.             $xx = $fNum - 0.785398164;

    608. 

  608.             $f1 = 1 + $y * (- 0.1098628627e-2 + $y * (0.2734510407e-4 + $y * (- 0.2073370639e-5 + $y * 0.2093887211e-6)));

    609. 

  609.             $f2 = - 0.1562499995e-1 + $y * (0.1430488765e-3 + $y * (- 0.6911147651e-5 + $y * (0.7621095161e-6 + $y * (- 0.934945152e-7))));

    610. 

  610.             $fRet = sqrt(M_2DIVPI / $fNum) * (sin($xx) * $f1 + $z * cos($xx) * $f2);

    611. 

  611.         }

    612. 

  612.         return $fRet;

    613. 

  613.     } //	function _Bessely0()
    614. 

  614. 

    615. 

  615.     

    616. 

  616.     private static function _Bessely1($fNum)

    617. 

  617.     {

    618. 

  618.         if ($fNum < 8.0)

    619. 

  619.         {

    620. 

  620.             $y = ($fNum * $fNum);

    621. 

  621.             $f1 = $fNum * (- 0.4900604943e13 + $y * (0.1275274390e13 + $y * (- 0.5153438139e11 + $y * (0.7349264551e9 + $y * (- 0.4237922726e7 + $y * 0.8511937935e4)))));

    622. 

  622.             $f2 = 0.2499580570e14 + $y * (0.4244419664e12 + $y * (0.3733650367e10 + $y * (0.2245904002e8 + $y * (0.1020426050e6 + $y * (0.3549632885e3 + $y)))));

    623. 

  623.             $fRet = $f1 / $f2 + M_2DIVPI * (self :: BESSELJ($fNum, 1) * log($fNum) - 1 / $fNum);

    624. 

  624.         }

    625. 

  625.         else

    626. 

  626.         {

    627. 

  627.             $z = 8.0 / $fNum;

    628. 

  628.             $y = ($z * $z);

    629. 

  629.             $xx = $fNum - 2.356194491;

    630. 

  630.             $f1 = 1 + $y * (0.183105e-2 + $y * (- 0.3516396496e-4 + $y * (0.2457520174e-5 + $y * (- 0.240337019e6))));

    631. 

  631.             $f2 = 0.04687499995 + $y * (- 0.2002690873e-3 + $y * (0.8449199096e-5 + $y * (- 0.88228987e-6 + $y * 0.105787412e-6)));

    632. 

  632.             $fRet = sqrt(M_2DIVPI / $fNum) * (sin($xx) * $f1 + $z * cos($xx) * $f2);

    633. 

  633.         

    634. 

  634.      #i12430# ...but this seems to work much better.
    635. 

  635.         //			$fRet = sqrt(M_2DIVPI / $fNum) * sin($fNum - 2.356194491);
    636. 

  636.         }

    637. 

  637.         return $fRet;

    638. 

  638.     } //	function _Bessely1()
    639. 

  639. 

    640. 

  640.     

    641. 

  641.     /**
    642. 

  642.      * BESSELY
    643. 

  643.      *
    644. 

  644.      * Returns the Bessel function, which is also called the Weber function or the Neumann function.
    645. 

  645.      *
    646. 

  646.      * @param	float		$x
    647. 

  647.      * @param	float		$n
    648. 

  648.      * @return	int
    649. 

  649.      */

    650. 

  650.     public static function BESSELY($x, $ord)

    651. 

  651.     {

    652. 

  652.         $x = (is_null($x)) ? 0.0 : PHPExcel_Calculation_Functions :: flattenSingleValue($x);

    653. 

  653.         $ord = (is_null($ord)) ? 0.0 : PHPExcel_Calculation_Functions :: flattenSingleValue($ord);

    654. 

  654.         

    655. 

  655.         if ((is_numeric($x)) && (is_numeric($ord)))

    656. 

  656.         {

    657. 

  657.             if (($ord < 0) || ($x == 0.0))

    658. 

  658.             {

    659. 

  659.                 return PHPExcel_Calculation_Functions :: NaN();

    660. 

  660.             }

    661. 

  661.             

    662. 

  662.             switch (floor($ord))

    663. 

  663.             {

    664. 

  664.                 case 0 :

    665. 

  665.                     return self :: _Bessely0($x);

    666. 

  666.                     break;

    667. 

  667.                 case 1 :

    668. 

  668.                     return self :: _Bessely1($x);

    669. 

  669.                     break;

    670. 

  670.                 default :

    671. 

  671.                     $fTox = 2 / $x;

    672. 

  672.                     $fBym = self :: _Bessely0($x);

    673. 

  673.                     $fBy = self :: _Bessely1($x);

    674. 

  674.                     for($n = 1; $n < $ord; ++ $n)

    675. 

  675.                     {

    676. 

  676.                         $fByp = $n * $fTox * $fBy - $fBym;

    677. 

  677.                         $fBym = $fBy;

    678. 

  678.                         $fBy = $fByp;

    679. 

  679.                     }

    680. 

  680.             }

    681. 

  681.             return $fBy;

    682. 

  682.         }

    683. 

  683.         return PHPExcel_Calculation_Functions :: VALUE();

    684. 

  684.     } //	function BESSELY()
    685. 

  685. 

    686. 

  686.     

    687. 

  687.     /**
    688. 

  688.      * BINTODEC
    689. 

  689.      *
    690. 

  690.      * Return a binary value as Decimal.
    691. 

  691.      *
    692. 

  692.      * @param	string		$x
    693. 

  693.      * @return	string
    694. 

  694.      */

    695. 

  695.     public static function BINTODEC($x)

    696. 

  696.     {

    697. 

  697.         $x = PHPExcel_Calculation_Functions :: flattenSingleValue($x);

    698. 

  698.         

    699. 

  699.         if (is_bool($x))

    700. 

  700.         {

    701. 

  701.             if (PHPExcel_Calculation_Functions :: getCompatibilityMode() == PHPExcel_Calculation_Functions :: COMPATIBILITY_OPENOFFICE)

    702. 

  702.             {

    703. 

  703.                 $x = (int) $x;

    704. 

  704.             }

    705. 

  705.             else

    706. 

  706.             {

    707. 

  707.                 return PHPExcel_Calculation_Functions :: VALUE();

    708. 

  708.             }

    709. 

  709.         }

    710. 

  710.         if (PHPExcel_Calculation_Functions :: getCompatibilityMode() == PHPExcel_Calculation_Functions :: COMPATIBILITY_GNUMERIC)

    711. 

  711.         {

    712. 

  712.             $x = floor($x);

    713. 

  713.         }

    714. 

  714.         $x = (string) $x;

    715. 

  715.         if (strlen($x) > preg_match_all('/[01]/', $x, $out))

    716. 

  716.         {

    717. 

  717.             return PHPExcel_Calculation_Functions :: NaN();

    718. 

  718.         }

    719. 

  719.         if (strlen($x) > 10)

    720. 

  720.         {

    721. 

  721.             return PHPExcel_Calculation_Functions :: NaN();

    722. 

  722.         }

    723. 

  723.         elseif (strlen($x) == 10)

    724. 

  724.         {

    725. 

  725.             //	Two's Complement
    726. 

  726.             $x = substr($x, - 9);

    727. 

  727.             return '-' . (512 - bindec($x));

    728. 

  728.         }

    729. 

  729.         return bindec($x);

    730. 

  730.     } //	function BINTODEC()
    731. 

  731. 

    732. 

  732.     

    733. 

  733.     /**
    734. 

  734.      * BINTOHEX
    735. 

  735.      *
    736. 

  736.      * Return a binary value as Hex.
    737. 

  737.      *
    738. 

  738.      * @param	string		$x
    739. 

  739.      * @return	string
    740. 

  740.      */

    741. 

  741.     public static function BINTOHEX($x, $places = null)

    742. 

  742.     {

    743. 

  743.         $x = floor(PHPExcel_Calculation_Functions :: flattenSingleValue($x));

    744. 

  744.         $places = PHPExcel_Calculation_Functions :: flattenSingleValue($places);

    745. 

  745.         

    746. 

  746.         if (is_bool($x))

    747. 

  747.         {

    748. 

  748.             if (PHPExcel_Calculation_Functions :: getCompatibilityMode() == PHPExcel_Calculation_Functions :: COMPATIBILITY_OPENOFFICE)

    749. 

  749.             {

    750. 

  750.                 $x = (int) $x;

    751. 

  751.             }

    752. 

  752.             else

    753. 

  753.             {

    754. 

  754.                 return PHPExcel_Calculation_Functions :: VALUE();

    755. 

  755.             }

    756. 

  756.         }

    757. 

  757.         if (PHPExcel_Calculation_Functions :: getCompatibilityMode() == PHPExcel_Calculation_Functions :: COMPATIBILITY_GNUMERIC)

    758. 

  758.         {

    759. 

  759.             $x = floor($x);

    760. 

  760.         }

    761. 

  761.         $x = (string) $x;

    762. 

  762.         if (strlen($x) > preg_match_all('/[01]/', $x, $out))

    763. 

  763.         {

    764. 

  764.             return PHPExcel_Calculation_Functions :: NaN();

    765. 

  765.         }

    766. 

  766.         if (strlen($x) > 10)

    767. 

  767.         {

    768. 

  768.             return PHPExcel_Calculation_Functions :: NaN();

    769. 

  769.         }

    770. 

  770.         elseif (strlen($x) == 10)

    771. 

  771.         {

    772. 

  772.             //	Two's Complement
    773. 

  773.             return str_repeat('F', 8) . substr(strtoupper(dechex(bindec(substr($x, - 9)))), - 2);

    774. 

  774.         }

    775. 

  775.         $hexVal = (string) strtoupper(dechex(bindec($x)));

    776. 

  776.         

    777. 

  777.         return self :: _nbrConversionFormat($hexVal, $places);

    778. 

  778.     } //	function BINTOHEX()
    779. 

  779. 

    780. 

  780.     

    781. 

  781.     /**
    782. 

  782.      * BINTOOCT
    783. 

  783.      *
    784. 

  784.      * Return a binary value as Octal.
    785. 

  785.      *
    786. 

  786.      * @param	string		$x
    787. 

  787.      * @return	string
    788. 

  788.      */

    789. 

  789.     public static function BINTOOCT($x, $places = null)

    790. 

  790.     {

    791. 

  791.         $x = floor(PHPExcel_Calculation_Functions :: flattenSingleValue($x));

    792. 

  792.         $places = PHPExcel_Calculation_Functions :: flattenSingleValue($places);

    793. 

  793.         

    794. 

  794.         if (is_bool($x))

    795. 

  795.         {

    796. 

  796.             if (PHPExcel_Calculation_Functions :: getCompatibilityMode() == PHPExcel_Calculation_Functions :: COMPATIBILITY_OPENOFFICE)

    797. 

  797.             {

    798. 

  798.                 $x = (int) $x;

    799. 

  799.             }

    800. 

  800.             else

    801. 

  801.             {

    802. 

  802.                 return PHPExcel_Calculation_Functions :: VALUE();

    803. 

  803.             }

    804. 

  804.         }

    805. 

  805.         if (PHPExcel_Calculation_Functions :: getCompatibilityMode() == PHPExcel_Calculation_Functions :: COMPATIBILITY_GNUMERIC)

    806. 

  806.         {

    807. 

  807.             $x = floor($x);

    808. 

  808.         }

    809. 

  809.         $x = (string) $x;

    810. 

  810.         if (strlen($x) > preg_match_all('/[01]/', $x, $out))

    811. 

  811.         {

    812. 

  812.             return PHPExcel_Calculation_Functions :: NaN();

    813. 

  813.         }

    814. 

  814.         if (strlen($x) > 10)

    815. 

  815.         {

    816. 

  816.             return PHPExcel_Calculation_Functions :: NaN();

    817. 

  817.         }

    818. 

  818.         elseif (strlen($x) == 10)

    819. 

  819.         {

    820. 

  820.             //	Two's Complement
    821. 

  821.             return str_repeat('7', 7) . substr(strtoupper(decoct(bindec(substr($x, - 9)))), - 3);

    822. 

  822.         }

    823. 

  823.         $octVal = (string) decoct(bindec($x));

    824. 

  824.         

    825. 

  825.         return self :: _nbrConversionFormat($octVal, $places);

    826. 

  826.     } //	function BINTOOCT()
    827. 

  827. 

    828. 

  828.     

    829. 

  829.     /**
    830. 

  830.      * DECTOBIN
    831. 

  831.      *
    832. 

  832.      * Return an octal value as binary.
    833. 

  833.      *
    834. 

  834.      * @param	string		$x
    835. 

  835.      * @return	string
    836. 

  836.      */

    837. 

  837.     public static function DECTOBIN($x, $places = null)

    838. 

  838.     {

    839. 

  839.         $x = PHPExcel_Calculation_Functions :: flattenSingleValue($x);

    840. 

  840.         $places = PHPExcel_Calculation_Functions :: flattenSingleValue($places);

    841. 

  841.         

    842. 

  842.         if (is_bool($x))

    843. 

  843.         {

    844. 

  844.             if (PHPExcel_Calculation_Functions :: getCompatibilityMode() == PHPExcel_Calculation_Functions :: COMPATIBILITY_OPENOFFICE)

    845. 

  845.             {

    846. 

  846.                 $x = (int) $x;

    847. 

  847.             }

    848. 

  848.             else

    849. 

  849.             {

    850. 

  850.                 return PHPExcel_Calculation_Functions :: VALUE();

    851. 

  851.             }

    852. 

  852.         }

    853. 

  853.         $x = (string) $x;

    854. 

  854.         if (strlen($x) > preg_match_all('/[-0123456789.]/', $x, $out))

    855. 

  855.         {

    856. 

  856.             return PHPExcel_Calculation_Functions :: VALUE();

    857. 

  857.         }

    858. 

  858.         $x = (string) floor($x);

    859. 

  859.         $r = decbin($x);

    860. 

  860.         if (strlen($r) == 32)

    861. 

  861.         {

    862. 

  862.             //	Two's Complement
    863. 

  863.             $r = substr($r, - 10);

    864. 

  864.         }

    865. 

  865.         elseif (strlen($r) > 11)

    866. 

  866.         {

    867. 

  867.             return PHPExcel_Calculation_Functions :: NaN();

    868. 

  868.         }

    869. 

  869.         

    870. 

  870.         return self :: _nbrConversionFormat($r, $places);

    871. 

  871.     } //	function DECTOBIN()
    872. 

  872. 

    873. 

  873.     

    874. 

  874.     /**
    875. 

  875.      * DECTOHEX
    876. 

  876.      *
    877. 

  877.      * Return an octal value as binary.
    878. 

  878.      *
    879. 

  879.      * @param	string		$x
    880. 

  880.      * @return	string
    881. 

  881.      */

    882. 

  882.     public static function DECTOHEX($x, $places = null)

    883. 

  883.     {

    884. 

  884.         $x = PHPExcel_Calculation_Functions :: flattenSingleValue($x);

    885. 

  885.         $places = PHPExcel_Calculation_Functions :: flattenSingleValue($places);

    886. 

  886.         

    887. 

  887.         if (is_bool($x))

    888. 

  888.         {

    889. 

  889.             if (PHPExcel_Calculation_Functions :: getCompatibilityMode() == PHPExcel_Calculation_Functions :: COMPATIBILITY_OPENOFFICE)

    890. 

  890.             {

    891. 

  891.                 $x = (int) $x;

    892. 

  892.             }

    893. 

  893.             else

    894. 

  894.             {

    895. 

  895.                 return PHPExcel_Calculation_Functions :: VALUE();

    896. 

  896.             }

    897. 

  897.         }

    898. 

  898.         $x = (string) $x;

    899. 

  899.         if (strlen($x) > preg_match_all('/[-0123456789.]/', $x, $out))

    900. 

  900.         {

    901. 

  901.             return PHPExcel_Calculation_Functions :: VALUE();

    902. 

  902.         }

    903. 

  903.         $x = (string) floor($x);

    904. 

  904.         $r = strtoupper(dechex($x));

    905. 

  905.         if (strlen($r) == 8)

    906. 

  906.         {

    907. 

  907.             //	Two's Complement
    908. 

  908.             $r = 'FF' . $r;

    909. 

  909.         }

    910. 

  910.         

    911. 

  911.         return self :: _nbrConversionFormat($r, $places);

    912. 

  912.     } //	function DECTOHEX()
    913. 

  913. 

    914. 

  914.     

    915. 

  915.     /**
    916. 

  916.      * DECTOOCT
    917. 

  917.      *
    918. 

  918.      * Return an octal value as binary.
    919. 

  919.      *
    920. 

  920.      * @param	string		$x
    921. 

  921.      * @return	string
    922. 

  922.      */

    923. 

  923.     public static function DECTOOCT($x, $places = null)

    924. 

  924.     {

    925. 

  925.         $x = PHPExcel_Calculation_Functions :: flattenSingleValue($x);

    926. 

  926.         $places = PHPExcel_Calculation_Functions :: flattenSingleValue($places);

    927. 

  927.         

    928. 

  928.         if (is_bool($x))

    929. 

  929.         {

    930. 

  930.             if (PHPExcel_Calculation_Functions :: getCompatibilityMode() == PHPExcel_Calculation_Functions :: COMPATIBILITY_OPENOFFICE)

    931. 

  931.             {

    932. 

  932.                 $x = (int) $x;

    933. 

  933.             }

    934. 

  934.             else

    935. 

  935.             {

    936. 

  936.                 return PHPExcel_Calculation_Functions :: VALUE();

    937. 

  937.             }

    938. 

  938.         }

    939. 

  939.         $x = (string) $x;

    940. 

  940.         if (strlen($x) > preg_match_all('/[-0123456789.]/', $x, $out))

    941. 

  941.         {

    942. 

  942.             return PHPExcel_Calculation_Functions :: VALUE();

    943. 

  943.         }

    944. 

  944.         $x = (string) floor($x);

    945. 

  945.         $r = decoct($x);

    946. 

  946.         if (strlen($r) == 11)

    947. 

  947.         {

    948. 

  948.             //	Two's Complement
    949. 

  949.             $r = substr($r, - 10);

    950. 

  950.         }

    951. 

  951.         

    952. 

  952.         return self :: _nbrConversionFormat($r, $places);

    953. 

  953.     } //	function DECTOOCT()
    954. 

  954. 

    955. 

  955.     

    956. 

  956.     /**
    957. 

  957.      * HEXTOBIN
    958. 

  958.      *
    959. 

  959.      * Return a hex value as binary.
    960. 

  960.      *
    961. 

  961.      * @param	string		$x
    962. 

  962.      * @return	string
    963. 

  963.      */

    964. 

  964.     public static function HEXTOBIN($x, $places = null)

    965. 

  965.     {

    966. 

  966.         $x = PHPExcel_Calculation_Functions :: flattenSingleValue($x);

    967. 

  967.         $places = PHPExcel_Calculation_Functions :: flattenSingleValue($places);

    968. 

  968.         

    969. 

  969.         if (is_bool($x))

    970. 

  970.         {

    971. 

  971.             return PHPExcel_Calculation_Functions :: VALUE();

    972. 

  972.         }

    973. 

  973.         $x = (string) $x;

    974. 

  974.         if (strlen($x) > preg_match_all('/[0123456789ABCDEF]/', strtoupper($x), $out))

    975. 

  975.         {

    976. 

  976.             return PHPExcel_Calculation_Functions :: NaN();

    977. 

  977.         }

    978. 

  978.         $binVal = decbin(hexdec($x));

    979. 

  979.         

    980. 

  980.         return substr(self :: _nbrConversionFormat($binVal, $places), - 10);

    981. 

  981.     } //	function HEXTOBIN()
    982. 

  982. 

    983. 

  983.     

    984. 

  984.     /**
    985. 

  985.      * HEXTODEC
    986. 

  986.      *
    987. 

  987.      * Return a hex value as octal.
    988. 

  988.      *
    989. 

  989.      * @param	string		$x
    990. 

  990.      * @return	string
    991. 

  991.      */

    992. 

  992.     public static function HEXTODEC($x)

    993. 

  993.     {

    994. 

  994.         $x = PHPExcel_Calculation_Functions :: flattenSingleValue($x);

    995. 

  995.         

    996. 

  996.         if (is_bool($x))

    997. 

  997.         {

    998. 

  998.             return PHPExcel_Calculation_Functions :: VALUE();

    999. 

  999.         }

    1000. 

  1000.         $x = (string) $x;

    1001. 

  1001.         if (strlen($x) > preg_match_all('/[0123456789ABCDEF]/', strtoupper($x), $out))

    1002. 

  1002.         {

    1003. 

  1003.             return PHPExcel_Calculation_Functions :: NaN();

    1004. 

  1004.         }

    1005. 

  1005.         return hexdec($x);

    1006. 

  1006.     } //	function HEXTODEC()
    1007. 

  1007. 

    1008. 

  1008.     

    1009. 

  1009.     /**
    1010. 

  1010.      * HEXTOOCT
    1011. 

  1011.      *
    1012. 

  1012.      * Return a hex value as octal.
    1013. 

  1013.      *
    1014. 

  1014.      * @param	string		$x
    1015. 

  1015.      * @return	string
    1016. 

  1016.      */

    1017. 

  1017.     public static function HEXTOOCT($x, $places = null)

    1018. 

  1018.     {

    1019. 

  1019.         $x = PHPExcel_Calculation_Functions :: flattenSingleValue($x);

    1020. 

  1020.         $places = PHPExcel_Calculation_Functions :: flattenSingleValue($places);

    1021. 

  1021.         

    1022. 

  1022.         if (is_bool($x))

    1023. 

  1023.         {

    1024. 

  1024.             return PHPExcel_Calculation_Functions :: VALUE();

    1025. 

  1025.         }

    1026. 

  1026.         $x = (string) $x;

    1027. 

  1027.         if (strlen($x) > preg_match_all('/[0123456789ABCDEF]/', strtoupper($x), $out))

    1028. 

  1028.         {

    1029. 

  1029.             return PHPExcel_Calculation_Functions :: NaN();

    1030. 

  1030.         }

    1031. 

  1031.         $octVal = decoct(hexdec($x));

    1032. 

  1032.         

    1033. 

  1033.         return self :: _nbrConversionFormat($octVal, $places);

    1034. 

  1034.     } //	function HEXTOOCT()
    1035. 

  1035. 

    1036. 

  1036.     

    1037. 

  1037.     /**
    1038. 

  1038.      * OCTTOBIN
    1039. 

  1039.      *
    1040. 

  1040.      * Return an octal value as binary.
    1041. 

  1041.      *
    1042. 

  1042.      * @param	string		$x
    1043. 

  1043.      * @return	string
    1044. 

  1044.      */

    1045. 

  1045.     public static function OCTTOBIN($x, $places = null)

    1046. 

  1046.     {

    1047. 

  1047.         $x = PHPExcel_Calculation_Functions :: flattenSingleValue($x);

    1048. 

  1048.         $places = PHPExcel_Calculation_Functions :: flattenSingleValue($places);

    1049. 

  1049.         

    1050. 

  1050.         if (is_bool($x))

    1051. 

  1051.         {

    1052. 

  1052.             return PHPExcel_Calculation_Functions :: VALUE();

    1053. 

  1053.         }

    1054. 

  1054.         $x = (string) $x;

    1055. 

  1055.         if (preg_match_all('/[01234567]/', $x, $out) != strlen($x))

    1056. 

  1056.         {

    1057. 

  1057.             return PHPExcel_Calculation_Functions :: NaN();

    1058. 

  1058.         }

    1059. 

  1059.         $r = decbin(octdec($x));

    1060. 

  1060.         

    1061. 

  1061.         return self :: _nbrConversionFormat($r, $places);

    1062. 

  1062.     } //	function OCTTOBIN()
    1063. 

  1063. 

    1064. 

  1064.     

    1065. 

  1065.     /**
    1066. 

  1066.      * OCTTODEC
    1067. 

  1067.      *
    1068. 

  1068.      * Return an octal value as binary.
    1069. 

  1069.      *
    1070. 

  1070.      * @param	string		$x
    1071. 

  1071.      * @return	string
    1072. 

  1072.      */

    1073. 

  1073.     public static function OCTTODEC($x)

    1074. 

  1074.     {

    1075. 

  1075.         $x = PHPExcel_Calculation_Functions :: flattenSingleValue($x);

    1076. 

  1076.         

    1077. 

  1077.         if (is_bool($x))

    1078. 

  1078.         {

    1079. 

  1079.             return PHPExcel_Calculation_Functions :: VALUE();

    1080. 

  1080.         }

    1081. 

  1081.         $x = (string) $x;

    1082. 

  1082.         if (preg_match_all('/[01234567]/', $x, $out) != strlen($x))

    1083. 

  1083.         {

    1084. 

  1084.             return PHPExcel_Calculation_Functions :: NaN();

    1085. 

  1085.         }

    1086. 

  1086.         return octdec($x);

    1087. 

  1087.     } //	function OCTTODEC()
    1088. 

  1088. 

    1089. 

  1089.     

    1090. 

  1090.     /**
    1091. 

  1091.      * OCTTOHEX
    1092. 

  1092.      *
    1093. 

  1093.      * Return an octal value as hex.
    1094. 

  1094.      *
    1095. 

  1095.      * @param	string		$x
    1096. 

  1096.      * @return	string
    1097. 

  1097.      */

    1098. 

  1098.     public static function OCTTOHEX($x, $places = null)

    1099. 

  1099.     {

    1100. 

  1100.         $x = PHPExcel_Calculation_Functions :: flattenSingleValue($x);

    1101. 

  1101.         $places = PHPExcel_Calculation_Functions :: flattenSingleValue($places);

    1102. 

  1102.         

    1103. 

  1103.         if (is_bool($x))

    1104. 

  1104.         {

    1105. 

  1105.             return PHPExcel_Calculation_Functions :: VALUE();

    1106. 

  1106.         }

    1107. 

  1107.         $x = (string) $x;

    1108. 

  1108.         if (preg_match_all('/[01234567]/', $x, $out) != strlen($x))

    1109. 

  1109.         {

    1110. 

  1110.             return PHPExcel_Calculation_Functions :: NaN();

    1111. 

  1111.         }

    1112. 

  1112.         $hexVal = strtoupper(dechex(octdec($x)));

    1113. 

  1113.         

    1114. 

  1114.         return self :: _nbrConversionFormat($hexVal, $places);

    1115. 

  1115.     } //	function OCTTOHEX()
    1116. 

  1116. 

    1117. 

  1117.     

    1118. 

  1118.     /**
    1119. 

  1119.      * COMPLEX
    1120. 

  1120.      *
    1121. 

  1121.      * returns a complex number of the form x + yi or x + yj.
    1122. 

  1122.      *
    1123. 

  1123.      * @param	float		$realNumber
    1124. 

  1124.      * @param	float		$imaginary
    1125. 

  1125.      * @param	string		$suffix
    1126. 

  1126.      * @return	string
    1127. 

  1127.      */

    1128. 

  1128.     public static function COMPLEX($realNumber = 0.0, $imaginary = 0.0, $suffix = 'i')

    1129. 

  1129.     {

    1130. 

  1130.         $realNumber = (is_null($realNumber)) ? 0.0 : (float) PHPExcel_Calculation_Functions :: flattenSingleValue($realNumber);

    1131. 

  1131.         $imaginary = (is_null($imaginary)) ? 0.0 : (float) PHPExcel_Calculation_Functions :: flattenSingleValue($imaginary);

    1132. 

  1132.         $suffix = (is_null($suffix)) ? 'i' : PHPExcel_Calculation_Functions :: flattenSingleValue($suffix);

    1133. 

  1133.         

    1134. 

  1134.         if (((is_numeric($realNumber)) && (is_numeric($imaginary))) && (($suffix == 'i') || ($suffix == 'j') || ($suffix == '')))

    1135. 

  1135.         {

    1136. 

  1136.             if ($suffix == '')

    1137. 

  1137.                 $suffix = 'i';

    1138. 

  1138.             if ($realNumber == 0.0)

    1139. 

  1139.             {

    1140. 

  1140.                 if ($imaginary == 0.0)

    1141. 

  1141.                 {

    1142. 

  1142.                     return (string) '0';

    1143. 

  1143.                 }

    1144. 

  1144.                 elseif ($imaginary == 1.0)

    1145. 

  1145.                 {

    1146. 

  1146.                     return (string) $suffix;

    1147. 

  1147.                 }

    1148. 

  1148.                 elseif ($imaginary == - 1.0)

    1149. 

  1149.                 {

    1150. 

  1150.                     return (string) '-' . $suffix;

    1151. 

  1151.                 }

    1152. 

  1152.                 return (string) $imaginary . $suffix;

    1153. 

  1153.             }

    1154. 

  1154.             elseif ($imaginary == 0.0)

    1155. 

  1155.             {

    1156. 

  1156.                 return (string) $realNumber;

    1157. 

  1157.             }

    1158. 

  1158.             elseif ($imaginary == 1.0)

    1159. 

  1159.             {

    1160. 

  1160.                 return (string) $realNumber . '+' . $suffix;

    1161. 

  1161.             }

    1162. 

  1162.             elseif ($imaginary == - 1.0)

    1163. 

  1163.             {

    1164. 

  1164.                 return (string) $realNumber . '-' . $suffix;

    1165. 

  1165.             }

    1166. 

  1166.             if ($imaginary > 0)

    1167. 

  1167.             {

    1168. 

  1168.                 $imaginary = (string) '+' . $imaginary;

    1169. 

  1169.             }

    1170. 

  1170.             return (string) $realNumber . $imaginary . $suffix;

    1171. 

  1171.         }

    1172. 

  1172.         

    1173. 

  1173.         return PHPExcel_Calculation_Functions :: VALUE();

    1174. 

  1174.     } //	function COMPLEX()
    1175. 

  1175. 

    1176. 

  1176.     

    1177. 

  1177.     /**
    1178. 

  1178.      * IMAGINARY
    1179. 

  1179.      *
    1180. 

  1180.      * Returns the imaginary coefficient of a complex number in x + yi or x + yj text format.
    1181. 

  1181.      *
    1182. 

  1182.      * @param	string		$complexNumber
    1183. 

  1183.      * @return	real
    1184. 

  1184.      */

    1185. 

  1185.     public static function IMAGINARY($complexNumber)

    1186. 

  1186.     {

    1187. 

  1187.         $complexNumber = PHPExcel_Calculation_Functions :: flattenSingleValue($complexNumber);

    1188. 

  1188.         

    1189. 

  1189.         $parsedComplex = self :: _parseComplex($complexNumber);

    1190. 

  1190.         if (! is_array($parsedComplex))

    1191. 

  1191.         {

    1192. 

  1192.             return $parsedComplex;

    1193. 

  1193.         }

    1194. 

  1194.         return $parsedComplex['imaginary'];

    1195. 

  1195.     } //	function IMAGINARY()
    1196. 

  1196. 

    1197. 

  1197.     

    1198. 

  1198.     /**
    1199. 

  1199.      * IMREAL
    1200. 

  1200.      *
    1201. 

  1201.      * Returns the real coefficient of a complex number in x + yi or x + yj text format.
    1202. 

  1202.      *
    1203. 

  1203.      * @param	string		$complexNumber
    1204. 

  1204.      * @return	real
    1205. 

  1205.      */

    1206. 

  1206.     public static function IMREAL($complexNumber)

    1207. 

  1207.     {

    1208. 

  1208.         $complexNumber = PHPExcel_Calculation_Functions :: flattenSingleValue($complexNumber);

    1209. 

  1209.         

    1210. 

  1210.         $parsedComplex = self :: _parseComplex($complexNumber);

    1211. 

  1211.         if (! is_array($parsedComplex))

    1212. 

  1212.         {

    1213. 

  1213.             return $parsedComplex;

    1214. 

  1214.         }

    1215. 

  1215.         return $parsedComplex['real'];

    1216. 

  1216.     } //	function IMREAL()
    1217. 

  1217. 

    1218. 

  1218.     

    1219. 

  1219.     /**
    1220. 

  1220.      * IMABS
    1221. 

  1221.      *
    1222. 

  1222.      * Returns the absolute value (modulus) of a complex number in x + yi or x + yj text format.
    1223. 

  1223.      *
    1224. 

  1224.      * @param	string		$complexNumber
    1225. 

  1225.      * @return	real
    1226. 

  1226.      */

    1227. 

  1227.     public static function IMABS($complexNumber)

    1228. 

  1228.     {

    1229. 

  1229.         $complexNumber = PHPExcel_Calculation_Functions :: flattenSingleValue($complexNumber);

    1230. 

  1230.         

    1231. 

  1231.         $parsedComplex = self :: _parseComplex($complexNumber);

    1232. 

  1232.         if (! is_array($parsedComplex))

    1233. 

  1233.         {

    1234. 

  1234.             return $parsedComplex;

    1235. 

  1235.         }

    1236. 

  1236.         return sqrt(($parsedComplex['real'] * $parsedComplex['real']) + ($parsedComplex['imaginary'] * $parsedComplex['imaginary']));

    1237. 

  1237.     } //	function IMABS()
    1238. 

  1238. 

    1239. 

  1239.     

    1240. 

  1240.     /**
    1241. 

  1241.      * IMARGUMENT
    1242. 

  1242.      *
    1243. 

  1243.      * 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.
    1244. 

  1244.      *
    1245. 

  1245.      * @param	string		$complexNumber
    1246. 

  1246.      * @return	string
    1247. 

  1247.      */

    1248. 

  1248.     public static function IMARGUMENT($complexNumber)

    1249. 

  1249.     {

    1250. 

  1250.         $complexNumber = PHPExcel_Calculation_Functions :: flattenSingleValue($complexNumber);

    1251. 

  1251.         

    1252. 

  1252.         $parsedComplex = self :: _parseComplex($complexNumber);

    1253. 

  1253.         if (! is_array($parsedComplex))

    1254. 

  1254.         {

    1255. 

  1255.             return $parsedComplex;

    1256. 

  1256.         }

    1257. 

  1257.         

    1258. 

  1258.         if ($parsedComplex['real'] == 0.0)

    1259. 

  1259.         {

    1260. 

  1260.             if ($parsedComplex['imaginary'] == 0.0)

    1261. 

  1261.             {

    1262. 

  1262.                 return 0.0;

    1263. 

  1263.             }

    1264. 

  1264.             elseif ($parsedComplex['imaginary'] < 0.0)

    1265. 

  1265.             {

    1266. 

  1266.                 return M_PI / - 2;

    1267. 

  1267.             }

    1268. 

  1268.             else

    1269. 

  1269.             {

    1270. 

  1270.                 return M_PI / 2;

    1271. 

  1271.             }

    1272. 

  1272.         }

    1273. 

  1273.         elseif ($parsedComplex['real'] > 0.0)

    1274. 

  1274.         {

    1275. 

  1275.             return atan($parsedComplex['imaginary'] / $parsedComplex['real']);

    1276. 

  1276.         }

    1277. 

  1277.         elseif ($parsedComplex['imaginary'] < 0.0)

    1278. 

  1278.         {

    1279. 

  1279.             return 0 - (M_PI - atan(abs($parsedComplex['imaginary']) / abs($parsedComplex['real'])));

    1280. 

  1280.         }

    1281. 

  1281.         else

    1282. 

  1282.         {

    1283. 

  1283.             return M_PI - atan($parsedComplex['imaginary'] / abs($parsedComplex['real']));

    1284. 

  1284.         }

    1285. 

  1285.     } //	function IMARGUMENT()
    1286. 

  1286. 

    1287. 

  1287.     

    1288. 

  1288.     /**
    1289. 

  1289.      * IMCONJUGATE
    1290. 

  1290.      *
    1291. 

  1291.      * Returns the complex conjugate of a complex number in x + yi or x + yj text format.
    1292. 

  1292.      *
    1293. 

  1293.      * @param	string		$complexNumber
    1294. 

  1294.      * @return	string
    1295. 

  1295.      */

    1296. 

  1296.     public static function IMCONJUGATE($complexNumber)

    1297. 

  1297.     {

    1298. 

  1298.         $complexNumber = PHPExcel_Calculation_Functions :: flattenSingleValue($complexNumber);

    1299. 

  1299.         

    1300. 

  1300.         $parsedComplex = self :: _parseComplex($complexNumber);

    1301. 

  1301.         

    1302. 

  1302.         if (! is_array($parsedComplex))

    1303. 

  1303.         {

    1304. 

  1304.             return $parsedComplex;

    1305. 

  1305.         }

    1306. 

  1306.         

    1307. 

  1307.         if ($parsedComplex['imaginary'] == 0.0)

    1308. 

  1308.         {

    1309. 

  1309.             return $parsedComplex['real'];

    1310. 

  1310.         }

    1311. 

  1311.         else

    1312. 

  1312.         {

    1313. 

  1313.             return self :: _cleanComplex(self :: COMPLEX($parsedComplex['real'], 0 - $parsedComplex['imaginary'], $parsedComplex['suffix']));

    1314. 

  1314.         }

    1315. 

  1315.     } //	function IMCONJUGATE()
    1316. 

  1316. 

    1317. 

  1317.     

    1318. 

  1318.     /**
    1319. 

  1319.      * IMCOS
    1320. 

  1320.      *
    1321. 

  1321.      * Returns the cosine of a complex number in x + yi or x + yj text format.
    1322. 

  1322.      *
    1323. 

  1323.      * @param	string		$complexNumber
    1324. 

  1324.      * @return	string
    1325. 

  1325.      */

    1326. 

  1326.     public static function IMCOS($complexNumber)

    1327. 

  1327.     {

    1328. 

  1328.         $complexNumber = PHPExcel_Calculation_Functions :: flattenSingleValue($complexNumber);

    1329. 

  1329.         

    1330. 

  1330.         $parsedComplex = self :: _parseComplex($complexNumber);

    1331. 

  1331.         if (! is_array($parsedComplex))

    1332. 

  1332.         {

    1333. 

  1333.             return $parsedComplex;

    1334. 

  1334.         }

    1335. 

  1335.         

    1336. 

  1336.         if ($parsedComplex['imaginary'] == 0.0)

    1337. 

  1337.         {

    1338. 

  1338.             return cos($parsedComplex['real']);

    1339. 

  1339.         }

    1340. 

  1340.         else

    1341. 

  1341.         {

    1342. 

  1342.             return self :: IMCONJUGATE(self :: COMPLEX(cos($parsedComplex['real']) * cosh($parsedComplex['imaginary']), sin($parsedComplex['real']) * sinh($parsedComplex['imaginary']), $parsedComplex['suffix']));

    1343. 

  1343.         }

    1344. 

  1344.     } //	function IMCOS()
    1345. 

  1345. 

    1346. 

  1346.     

    1347. 

  1347.     /**
    1348. 

  1348.      * IMSIN
    1349. 

  1349.      *
    1350. 

  1350.      * Returns the sine of a complex number in x + yi or x + yj text format.
    1351. 

  1351.      *
    1352. 

  1352.      * @param	string		$complexNumber
    1353. 

  1353.      * @return	string
    1354. 

  1354.      */

    1355. 

  1355.     public static function IMSIN($complexNumber)

    1356. 

  1356.     {

    1357. 

  1357.         $complexNumber = PHPExcel_Calculation_Functions :: flattenSingleValue($complexNumber);

    1358. 

  1358.         

    1359. 

  1359.         $parsedComplex = self :: _parseComplex($complexNumber);

    1360. 

  1360.         if (! is_array($parsedComplex))

    1361. 

  1361.         {

    1362. 

  1362.             return $parsedComplex;

    1363. 

  1363.         }

    1364. 

  1364.         

    1365. 

  1365.         if ($parsedComplex['imaginary'] == 0.0)

    1366. 

  1366.         {

    1367. 

  1367.             return sin($parsedComplex['real']);

    1368. 

  1368.         }

    1369. 

  1369.         else

    1370. 

  1370.         {

    1371. 

  1371.             return self :: COMPLEX(sin($parsedComplex['real']) * cosh($parsedComplex['imaginary']), cos($parsedComplex['real']) * sinh($parsedComplex['imaginary']), $parsedComplex['suffix']);

    1372. 

  1372.         }

    1373. 

  1373.     } //	function IMSIN()
    1374. 

  1374. 

    1375. 

  1375.     

    1376. 

  1376.     /**
    1377. 

  1377.      * IMSQRT
    1378. 

  1378.      *
    1379. 

  1379.      * Returns the square root of a complex number in x + yi or x + yj text format.
    1380. 

  1380.      *
    1381. 

  1381.      * @param	string		$complexNumber
    1382. 

  1382.      * @return	string
    1383. 

  1383.      */

    1384. 

  1384.     public static function IMSQRT($complexNumber)

    1385. 

  1385.     {

    1386. 

  1386.         $complexNumber = PHPExcel_Calculation_Functions :: flattenSingleValue($complexNumber);

    1387. 

  1387.         

    1388. 

  1388.         $parsedComplex = self :: _parseComplex($complexNumber);

    1389. 

  1389.         if (! is_array($parsedComplex))

    1390. 

  1390.         {

    1391. 

  1391.             return $parsedComplex;

    1392. 

  1392.         }

    1393. 

  1393.         

    1394. 

  1394.         $theta = self :: IMARGUMENT($complexNumber);

    1395. 

  1395.         $d1 = cos($theta / 2);

    1396. 

  1396.         $d2 = sin($theta / 2);

    1397. 

  1397.         $r = sqrt(sqrt(($parsedComplex['real'] * $parsedComplex['real']) + ($parsedComplex['imaginary'] * $parsedComplex['imaginary'])));

    1398. 

  1398.         

    1399. 

  1399.         if ($parsedComplex['suffix'] == '')

    1400. 

  1400.         {

    1401. 

  1401.             return self :: COMPLEX($d1 * $r, $d2 * $r);

    1402. 

  1402.         }

    1403. 

  1403.         else

    1404. 

  1404.         {

    1405. 

  1405.             return self :: COMPLEX($d1 * $r, $d2 * $r, $parsedComplex['suffix']);

    1406. 

  1406.         }

    1407. 

  1407.     } //	function IMSQRT()
    1408. 

  1408. 

    1409. 

  1409.     

    1410. 

  1410.     /**
    1411. 

  1411.      * IMLN
    1412. 

  1412.      *
    1413. 

  1413.      * Returns the natural logarithm of a complex number in x + yi or x + yj text format.
    1414. 

  1414.      *
    1415. 

  1415.      * @param	string		$complexNumber
    1416. 

  1416.      * @return	string
    1417. 

  1417.      */

    1418. 

  1418.     public static function IMLN($complexNumber)

    1419. 

  1419.     {

    1420. 

  1420.         $complexNumber = PHPExcel_Calculation_Functions :: flattenSingleValue($complexNumber);

    1421. 

  1421.         

    1422. 

  1422.         $parsedComplex = self :: _parseComplex($complexNumber);

    1423. 

  1423.         if (! is_array($parsedComplex))

    1424. 

  1424.         {

    1425. 

  1425.             return $parsedComplex;

    1426. 

  1426.         }

    1427. 

  1427.         

    1428. 

  1428.         if (($parsedComplex['real'] == 0.0) && ($parsedComplex['imaginary'] == 0.0))

    1429. 

  1429.         {

    1430. 

  1430.             return PHPExcel_Calculation_Functions :: NaN();

    1431. 

  1431.         }

    1432. 

  1432.         

    1433. 

  1433.         $logR = log(sqrt(($parsedComplex['real'] * $parsedComplex['real']) + ($parsedComplex['imaginary'] * $parsedComplex['imaginary'])));

    1434. 

  1434.         $t = self :: IMARGUMENT($complexNumber);

    1435. 

  1435.         

    1436. 

  1436.         if ($parsedComplex['suffix'] == '')

    1437. 

  1437.         {

    1438. 

  1438.             return self :: COMPLEX($logR, $t);

    1439. 

  1439.         }

    1440. 

  1440.         else

    1441. 

  1441.         {

    1442. 

  1442.             return self :: COMPLEX($logR, $t, $parsedComplex['suffix']);

    1443. 

  1443.         }

    1444. 

  1444.     } //	function IMLN()
    1445. 

  1445. 

    1446. 

  1446.     

    1447. 

  1447.     /**
    1448. 

  1448.      * IMLOG10
    1449. 

  1449.      *
    1450. 

  1450.      * Returns the common logarithm (base 10) of a complex number in x + yi or x + yj text format.
    1451. 

  1451.      *
    1452. 

  1452.      * @param	string		$complexNumber
    1453. 

  1453.      * @return	string
    1454. 

  1454.      */

    1455. 

  1455.     public static function IMLOG10($complexNumber)

    1456. 

  1456.     {

    1457. 

  1457.         $complexNumber = PHPExcel_Calculation_Functions :: flattenSingleValue($complexNumber);

    1458. 

  1458.         

    1459. 

  1459.         $parsedComplex = self :: _parseComplex($complexNumber);

    1460. 

  1460.         if (! is_array($parsedComplex))

    1461. 

  1461.         {

    1462. 

  1462.             return $parsedComplex;

    1463. 

  1463.         }

    1464. 

  1464.         

    1465. 

  1465.         if (($parsedComplex['real'] == 0.0) && ($parsedComplex['imaginary'] == 0.0))

    1466. 

  1466.         {

    1467. 

  1467.             return PHPExcel_Calculation_Functions :: NaN();

    1468. 

  1468.         }

    1469. 

  1469.         elseif (($parsedComplex['real'] > 0.0) && ($parsedComplex['imaginary'] == 0.0))

    1470. 

  1470.         {

    1471. 

  1471.             return log10($parsedComplex['real']);

    1472. 

  1472.         }

    1473. 

  1473.         

    1474. 

  1474.         return self :: IMPRODUCT(log10(EULER), self :: IMLN($complexNumber));

    1475. 

  1475.     } //	function IMLOG10()
    1476. 

  1476. 

    1477. 

  1477.     

    1478. 

  1478.     /**
    1479. 

  1479.      * IMLOG2
    1480. 

  1480.      *
    1481. 

  1481.      * Returns the common logarithm (base 10) of a complex number in x + yi or x + yj text format.
    1482. 

  1482.      *
    1483. 

  1483.      * @param	string		$complexNumber
    1484. 

  1484.      * @return	string
    1485. 

  1485.      */

    1486. 

  1486.     public static function IMLOG2($complexNumber)

    1487. 

  1487.     {

    1488. 

  1488.         $complexNumber = PHPExcel_Calculation_Functions :: flattenSingleValue($complexNumber);

    1489. 

  1489.         

    1490. 

  1490.         $parsedComplex = self :: _parseComplex($complexNumber);

    1491. 

  1491.         if (! is_array($parsedComplex))

    1492. 

  1492.         {

    1493. 

  1493.             return $parsedComplex;

    1494. 

  1494.         }

    1495. 

  1495.         

    1496. 

  1496.         if (($parsedComplex['real'] == 0.0) && ($parsedComplex['imaginary'] == 0.0))

    1497. 

  1497.         {

    1498. 

  1498.             return PHPExcel_Calculation_Functions :: NaN();

    1499. 

  1499.         }

    1500. 

  1500.         elseif (($parsedComplex['real'] > 0.0) && ($parsedComplex['imaginary'] == 0.0))

    1501. 

  1501.         {

    1502. 

  1502.             return log($parsedComplex['real'], 2);

    1503. 

  1503.         }

    1504. 

  1504.         

    1505. 

  1505.         return self :: IMPRODUCT(log(EULER, 2), self :: IMLN($complexNumber));

    1506. 

  1506.     } //	function IMLOG2()
    1507. 

  1507. 

    1508. 

  1508.     

    1509. 

  1509.     /**
    1510. 

  1510.      * IMEXP
    1511. 

  1511.      *
    1512. 

  1512.      * Returns the exponential of a complex number in x + yi or x + yj text format.
    1513. 

  1513.      *
    1514. 

  1514.      * @param	string		$complexNumber
    1515. 

  1515.      * @return	string
    1516. 

  1516.      */

    1517. 

  1517.     public static function IMEXP($complexNumber)

    1518. 

  1518.     {

    1519. 

  1519.         $complexNumber = PHPExcel_Calculation_Functions :: flattenSingleValue($complexNumber);

    1520. 

  1520.         

    1521. 

  1521.         $parsedComplex = self :: _parseComplex($complexNumber);

    1522. 

  1522.         if (! is_array($parsedComplex))

    1523. 

  1523.         {

    1524. 

  1524.             return $parsedComplex;

    1525. 

  1525.         }

    1526. 

  1526.         

    1527. 

  1527.         if (($parsedComplex['real'] == 0.0) && ($parsedComplex['imaginary'] == 0.0))

    1528. 

  1528.         {

    1529. 

  1529.             return '1';

    1530. 

  1530.         }

    1531. 

  1531.         

    1532. 

  1532.         $e = exp($parsedComplex['real']);

    1533. 

  1533.         $eX = $e * cos($parsedComplex['imaginary']);

    1534. 

  1534.         $eY = $e * sin($parsedComplex['imaginary']);

    1535. 

  1535.         

    1536. 

  1536.         if ($parsedComplex['suffix'] == '')

    1537. 

  1537.         {

    1538. 

  1538.             return self :: COMPLEX($eX, $eY);

    1539. 

  1539.         }

    1540. 

  1540.         else

    1541. 

  1541.         {

    1542. 

  1542.             return self :: COMPLEX($eX, $eY, $parsedComplex['suffix']);

    1543. 

  1543.         }

    1544. 

  1544.     } //	function IMEXP()
    1545. 

  1545. 

    1546. 

  1546.     

    1547. 

  1547.     /**
    1548. 

  1548.      * IMPOWER
    1549. 

  1549.      *
    1550. 

  1550.      * Returns a complex number in x + yi or x + yj text format raised to a power.
    1551. 

  1551.      *
    1552. 

  1552.      * @param	string		$complexNumber
    1553. 

  1553.      * @return	string
    1554. 

  1554.      */

    1555. 

  1555.     public static function IMPOWER($complexNumber, $realNumber)

    1556. 

  1556.     {

    1557. 

  1557.         $complexNumber = PHPExcel_Calculation_Functions :: flattenSingleValue($complexNumber);

    1558. 

  1558.         $realNumber = PHPExcel_Calculation_Functions :: flattenSingleValue($realNumber);

    1559. 

  1559.         

    1560. 

  1560.         if (! is_numeric($realNumber))

    1561. 

  1561.         {

    1562. 

  1562.             return PHPExcel_Calculation_Functions :: VALUE();

    1563. 

  1563.         }

    1564. 

  1564.         

    1565. 

  1565.         $parsedComplex = self :: _parseComplex($complexNumber);

    1566. 

  1566.         if (! is_array($parsedComplex))

    1567. 

  1567.         {

    1568. 

  1568.             return $parsedComplex;

    1569. 

  1569.         }

    1570. 

  1570.         

    1571. 

  1571.         $r = sqrt(($parsedComplex['real'] * $parsedComplex['real']) + ($parsedComplex['imaginary'] * $parsedComplex['imaginary']));

    1572. 

  1572.         $rPower = pow($r, $realNumber);

    1573. 

  1573.         $theta = self :: IMARGUMENT($complexNumber) * $realNumber;

    1574. 

  1574.         if ($theta == 0)

    1575. 

  1575.         {

    1576. 

  1576.             return 1;

    1577. 

  1577.         }

    1578. 

  1578.         elseif ($parsedComplex['imaginary'] == 0.0)

    1579. 

  1579.         {

    1580. 

  1580.             return self :: COMPLEX($rPower * cos($theta), $rPower * sin($theta), $parsedComplex['suffix']);

    1581. 

  1581.         }

    1582. 

  1582.         else

    1583. 

  1583.         {

    1584. 

  1584.             return self :: COMPLEX($rPower * cos($theta), $rPower * sin($theta), $parsedComplex['suffix']);

    1585. 

  1585.         }

    1586. 

  1586.     } //	function IMPOWER()
    1587. 

  1587. 

    1588. 

  1588.     

    1589. 

  1589.     /**
    1590. 

  1590.      * IMDIV
    1591. 

  1591.      *
    1592. 

  1592.      * Returns the quotient of two complex numbers in x + yi or x + yj text format.
    1593. 

  1593.      *
    1594. 

  1594.      * @param	string		$complexDividend
    1595. 

  1595.      * @param	string		$complexDivisor
    1596. 

  1596.      * @return	real
    1597. 

  1597.      */

    1598. 

  1598.     public static function IMDIV($complexDividend, $complexDivisor)

    1599. 

  1599.     {

    1600. 

  1600.         $complexDividend = PHPExcel_Calculation_Functions :: flattenSingleValue($complexDividend);

    1601. 

  1601.         $complexDivisor = PHPExcel_Calculation_Functions :: flattenSingleValue($complexDivisor);

    1602. 

  1602.         

    1603. 

  1603.         $parsedComplexDividend = self :: _parseComplex($complexDividend);

    1604. 

  1604.         if (! is_array($parsedComplexDividend))

    1605. 

  1605.         {

    1606. 

  1606.             return $parsedComplexDividend;

    1607. 

  1607.         }

    1608. 

  1608.         

    1609. 

  1609.         $parsedComplexDivisor = self :: _parseComplex($complexDivisor);

    1610. 

  1610.         if (! is_array($parsedComplexDivisor))

    1611. 

  1611.         {

    1612. 

  1612.             return $parsedComplexDividend;

    1613. 

  1613.         }

    1614. 

  1614.         

    1615. 

  1615.         if (($parsedComplexDividend['suffix'] != '') && ($parsedComplexDivisor['suffix'] != '') && ($parsedComplexDividend['suffix'] != $parsedComplexDivisor['suffix']))

    1616. 

  1616.         {

    1617. 

  1617.             return PHPExcel_Calculation_Functions :: NaN();

    1618. 

  1618.         }

    1619. 

  1619.         if (($parsedComplexDividend['suffix'] != '') && ($parsedComplexDivisor['suffix'] == ''))

    1620. 

  1620.         {

    1621. 

  1621.             $parsedComplexDivisor['suffix'] = $parsedComplexDividend['suffix'];

    1622. 

  1622.         }

    1623. 

  1623.         

    1624. 

  1624.         $d1 = ($parsedComplexDividend['real'] * $parsedComplexDivisor['real']) + ($parsedComplexDividend['imaginary'] * $parsedComplexDivisor['imaginary']);

    1625. 

  1625.         $d2 = ($parsedComplexDividend['imaginary'] * $parsedComplexDivisor['real']) - ($parsedComplexDividend['real'] * $parsedComplexDivisor['imaginary']);

    1626. 

  1626.         $d3 = ($parsedComplexDivisor['real'] * $parsedComplexDivisor['real']) + ($parsedComplexDivisor['imaginary'] * $parsedComplexDivisor['imaginary']);

    1627. 

  1627.         

    1628. 

  1628.         $r = $d1 / $d3;

    1629. 

  1629.         $i = $d2 / $d3;

    1630. 

  1630.         

    1631. 

  1631.         if ($i > 0.0)

    1632. 

  1632.         {

    1633. 

  1633.             return self :: _cleanComplex($r . '+' . $i . $parsedComplexDivisor['suffix']);

    1634. 

  1634.         }

    1635. 

  1635.         elseif ($i < 0.0)

    1636. 

  1636.         {

    1637. 

  1637.             return self :: _cleanComplex($r . $i . $parsedComplexDivisor['suffix']);

    1638. 

  1638.         }

    1639. 

  1639.         else

    1640. 

  1640.         {

    1641. 

  1641.             return $r;

    1642. 

  1642.         }

    1643. 

  1643.     } //	function IMDIV()
    1644. 

  1644. 

    1645. 

  1645.     

    1646. 

  1646.     /**
    1647. 

  1647.      * IMSUB
    1648. 

  1648.      *
    1649. 

  1649.      * Returns the difference of two complex numbers in x + yi or x + yj text format.
    1650. 

  1650.      *
    1651. 

  1651.      * @param	string		$complexNumber1
    1652. 

  1652.      * @param	string		$complexNumber2
    1653. 

  1653.      * @return	real
    1654. 

  1654.      */

    1655. 

  1655.     public static function IMSUB($complexNumber1, $complexNumber2)

    1656. 

  1656.     {

    1657. 

  1657.         $complexNumber1 = PHPExcel_Calculation_Functions :: flattenSingleValue($complexNumber1);

    1658. 

  1658.         $complexNumber2 = PHPExcel_Calculation_Functions :: flattenSingleValue($complexNumber2);

    1659. 

  1659.         

    1660. 

  1660.         $parsedComplex1 = self :: _parseComplex($complexNumber1);

    1661. 

  1661.         if (! is_array($parsedComplex1))

    1662. 

  1662.         {

    1663. 

  1663.             return $parsedComplex1;

    1664. 

  1664.         }

    1665. 

  1665.         

    1666. 

  1666.         $parsedComplex2 = self :: _parseComplex($complexNumber2);

    1667. 

  1667.         if (! is_array($parsedComplex2))

    1668. 

  1668.         {

    1669. 

  1669.             return $parsedComplex2;

    1670. 

  1670.         }

    1671. 

  1671.         

    1672. 

  1672.         if ((($parsedComplex1['suffix'] != '') && ($parsedComplex2['suffix'] != '')) && ($parsedComplex1['suffix'] != $parsedComplex2['suffix']))

    1673. 

  1673.         {

    1674. 

  1674.             return PHPExcel_Calculation_Functions :: NaN();

    1675. 

  1675.         }

    1676. 

  1676.         elseif (($parsedComplex1['suffix'] == '') && ($parsedComplex2['suffix'] != ''))

    1677. 

  1677.         {

    1678. 

  1678.             $parsedComplex1['suffix'] = $parsedComplex2['suffix'];

    1679. 

  1679.         }

    1680. 

  1680.         

    1681. 

  1681.         $d1 = $parsedComplex1['real'] - $parsedComplex2['real'];

    1682. 

  1682.         $d2 = $parsedComplex1['imaginary'] - $parsedComplex2['imaginary'];

    1683. 

  1683.         

    1684. 

  1684.         return self :: COMPLEX($d1, $d2, $parsedComplex1['suffix']);

    1685. 

  1685.     } //	function IMSUB()
    1686. 

  1686. 

    1687. 

  1687.     

    1688. 

  1688.     /**
    1689. 

  1689.      * IMSUM
    1690. 

  1690.      *
    1691. 

  1691.      * Returns the sum of two or more complex numbers in x + yi or x + yj text format.
    1692. 

  1692.      *
    1693. 

  1693.      * @param	array of mixed		Data Series
    1694. 

  1694.      * @return	real
    1695. 

  1695.      */

    1696. 

  1696.     public static function IMSUM()

    1697. 

  1697.     {

    1698. 

  1698.         // Return value
    1699. 

  1699.         $returnValue = self :: _parseComplex('0');

    1700. 

  1700.         $activeSuffix = '';

    1701. 

  1701.         

    1702. 

  1702.         // Loop through the arguments
    1703. 

  1703.         $aArgs = PHPExcel_Calculation_Functions :: flattenArray(func_get_args());

    1704. 

  1704.         foreach ($aArgs as $arg)

    1705. 

  1705.         {

    1706. 

  1706.             $parsedComplex = self :: _parseComplex($arg);

    1707. 

  1707.             if (! is_array($parsedComplex))

    1708. 

  1708.             {

    1709. 

  1709.                 return $parsedComplex;

    1710. 

  1710.             }

    1711. 

  1711.             

    1712. 

  1712.             if ($activeSuffix == '')

    1713. 

  1713.             {

    1714. 

  1714.                 $activeSuffix = $parsedComplex['suffix'];

    1715. 

  1715.             }

    1716. 

  1716.             elseif (($parsedComplex['suffix'] != '') && ($activeSuffix != $parsedComplex['suffix']))

    1717. 

  1717.             {

    1718. 

  1718.                 return PHPExcel_Calculation_Functions :: VALUE();

    1719. 

  1719.             }

    1720. 

  1720.             

    1721. 

  1721.             $returnValue['real'] += $parsedComplex['real'];

    1722. 

  1722.             $returnValue['imaginary'] += $parsedComplex['imaginary'];

    1723. 

  1723.         }

    1724. 

  1724.         

    1725. 

  1725.         if ($returnValue['imaginary'] == 0.0)

    1726. 

  1726.         {

    1727. 

  1727.             $activeSuffix = '';

    1728. 

  1728.         }

    1729. 

  1729.         return self :: COMPLEX($returnValue['real'], $returnValue['imaginary'], $activeSuffix);

    1730. 

  1730.     } //	function IMSUM()
    1731. 

  1731. 

    1732. 

  1732.     

    1733. 

  1733.     /**
    1734. 

  1734.      * IMPRODUCT
    1735. 

  1735.      *
    1736. 

  1736.      * Returns the product of two or more complex numbers in x + yi or x + yj text format.
    1737. 

  1737.      *
    1738. 

  1738.      * @param	array of mixed		Data Series
    1739. 

  1739.      * @return	real
    1740. 

  1740.      */

    1741. 

  1741.     public static function IMPRODUCT()

    1742. 

  1742.     {

    1743. 

  1743.         // Return value
    1744. 

  1744.         $returnValue = self :: _parseComplex('1');

    1745. 

  1745.         $activeSuffix = '';

    1746. 

  1746.         

    1747. 

  1747.         // Loop through the arguments
    1748. 

  1748.         $aArgs = PHPExcel_Calculation_Functions :: flattenArray(func_get_args());

    1749. 

  1749.         foreach ($aArgs as $arg)

    1750. 

  1750.         {

    1751. 

  1751.             $parsedComplex = self :: _parseComplex($arg);

    1752. 

  1752.             if (! is_array($parsedComplex))

    1753. 

  1753.             {

    1754. 

  1754.                 return $parsedComplex;

    1755. 

  1755.             }

    1756. 

  1756.             $workValue = $returnValue;

    1757. 

  1757.             if (($parsedComplex['suffix'] != '') && ($activeSuffix == ''))

    1758. 

  1758.             {

    1759. 

  1759.                 $activeSuffix = $parsedComplex['suffix'];

    1760. 

  1760.             }

    1761. 

  1761.             elseif (($parsedComplex['suffix'] != '') && ($activeSuffix != $parsedComplex['suffix']))

    1762. 

  1762.             {

    1763. 

  1763.                 return PHPExcel_Calculation_Functions :: NaN();

    1764. 

  1764.             }

    1765. 

  1765.             $returnValue['real'] = ($workValue['real'] * $parsedComplex['real']) - ($workValue['imaginary'] * $parsedComplex['imaginary']);

    1766. 

  1766.             $returnValue['imaginary'] = ($workValue['real'] * $parsedComplex['imaginary']) + ($workValue['imaginary'] * $parsedComplex['real']);

    1767. 

  1767.         }

    1768. 

  1768.         

    1769. 

  1769.         if ($returnValue['imaginary'] == 0.0)

    1770. 

  1770.         {

    1771. 

  1771.             $activeSuffix = '';

    1772. 

  1772.         }

    1773. 

  1773.         return self :: COMPLEX($returnValue['real'], $returnValue['imaginary'], $activeSuffix);

    1774. 

  1774.     } //	function IMPRODUCT()
    1775. 

  1775. 

    1776. 

  1776.     

    1777. 

  1777.     /**
    1778. 

  1778.      * DELTA
    1779. 

  1779.      *
    1780. 

  1780.      * Tests whether two values are equal. Returns 1 if number1 = number2; returns 0 otherwise.
    1781. 

  1781.      *
    1782. 

  1782.      * @param	float		$a
    1783. 

  1783.      * @param	float		$b
    1784. 

  1784.      * @return	int
    1785. 

  1785.      */

    1786. 

  1786.     public static function DELTA($a, $b = 0)

    1787. 

  1787.     {

    1788. 

  1788.         $a = PHPExcel_Calculation_Functions :: flattenSingleValue($a);

    1789. 

  1789.         $b = PHPExcel_Calculation_Functions :: flattenSingleValue($b);

    1790. 

  1790.         

    1791. 

  1791.         return (int) ($a == $b);

    1792. 

  1792.     } //	function DELTA()
    1793. 

  1793. 

    1794. 

  1794.     

    1795. 

  1795.     /**
    1796. 

  1796.      * GESTEP
    1797. 

  1797.      *
    1798. 

  1798.      * Returns 1 if number = step; returns 0 (zero) otherwise
    1799. 

  1799.      *
    1800. 

  1800.      * @param	float		$number
    1801. 

  1801.      * @param	float		$step
    1802. 

  1802.      * @return	int
    1803. 

  1803.      */

    1804. 

  1804.     public static function GESTEP($number, $step = 0)

    1805. 

  1805.     {

    1806. 

  1806.         $number = PHPExcel_Calculation_Functions :: flattenSingleValue($number);

    1807. 

  1807.         $step = PHPExcel_Calculation_Functions :: flattenSingleValue($step);

    1808. 

  1808.         

    1809. 

  1809.         return (int) ($number >= $step);

    1810. 

  1810.     } //	function GESTEP()
    1811. 

  1811.     

    1812. 

  1812. 

    1813. 

  1813.     //
    1814. 

  1814.     //	Private method to calculate the erf value
    1815. 

  1815.     //
    1816. 

  1816.     private static $_two_sqrtpi = 1.128379167095512574;

    1817. 

  1817. 

    1818. 

  1818.     public static function _erfVal($x)

    1819. 

  1819.     {

    1820. 

  1820.         if (abs($x) > 2.2)

    1821. 

  1821.         {

    1822. 

  1822.             return 1 - self :: _erfcVal($x);

    1823. 

  1823.         }

    1824. 

  1824.         $sum = $term = $x;

    1825. 

  1825.         $xsqr = ($x * $x);

    1826. 

  1826.         $j = 1;

    1827. 

  1827.         do

    1828. 

  1828.         {

    1829. 

  1829.             $term *= $xsqr / $j;

    1830. 

  1830.             $sum -= $term / (2 * $j + 1);

    1831. 

  1831.             ++ $j;

    1832. 

  1832.             $term *= $xsqr / $j;

    1833. 

  1833.             $sum += $term / (2 * $j + 1);

    1834. 

  1834.             ++ $j;

    1835. 

  1835.             if ($sum == 0.0)

    1836. 

  1836.             {

    1837. 

  1837.                 break;

    1838. 

  1838.             }

    1839. 

  1839.         }

    1840. 

  1840.         while (abs($term / $sum) > PRECISION);

    1841. 

  1841.         return self :: $_two_sqrtpi * $sum;

    1842. 

  1842.     } //	function _erfVal()
    1843. 

  1843. 

    1844. 

  1844.     

    1845. 

  1845.     /**
    1846. 

  1846.      * ERF
    1847. 

  1847.      *
    1848. 

  1848.      * Returns the error function integrated between lower_limit and upper_limit
    1849. 

  1849.      *
    1850. 

  1850.      * @param	float		$lower	lower bound for integrating ERF
    1851. 

  1851.      * @param	float		$upper	upper bound for integrating ERF.
    1852. 

  1852.      * If omitted, ERF integrates between zero and lower_limit
    1853. 

  1853.      * @return	int
    1854. 

  1854.      */

    1855. 

  1855.     public static function ERF($lower, $upper = null)

    1856. 

  1856.     {

    1857. 

  1857.         $lower = PHPExcel_Calculation_Functions :: flattenSingleValue($lower);

    1858. 

  1858.         $upper = PHPExcel_Calculation_Functions :: flattenSingleValue($upper);

    1859. 

  1859.         

    1860. 

  1860.         if (is_numeric($lower))

    1861. 

  1861.         {

    1862. 

  1862.             if ($lower < 0)

    1863. 

  1863.             {

    1864. 

  1864.                 return PHPExcel_Calculation_Functions :: NaN();

    1865. 

  1865.             }

    1866. 

  1866.             if (is_null($upper))

    1867. 

  1867.             {

    1868. 

  1868.                 return self :: _erfVal($lower);

    1869. 

  1869.             }

    1870. 

  1870.             if (is_numeric($upper))

    1871. 

  1871.             {

    1872. 

  1872.                 if ($upper < 0)

    1873. 

  1873.                 {

    1874. 

  1874.                     return PHPExcel_Calculation_Functions :: NaN();

    1875. 

  1875.                 }

    1876. 

  1876.                 return self :: _erfVal($upper) - self :: _erfVal($lower);

    1877. 

  1877.             }

    1878. 

  1878.         }

    1879. 

  1879.         return PHPExcel_Calculation_Functions :: VALUE();

    1880. 

  1880.     } //	function ERF()
    1881. 

  1881.     

    1882. 

  1882. 

    1883. 

  1883.     //
    1884. 

  1884.     //	Private method to calculate the erfc value
    1885. 

  1885.     //
    1886. 

  1886.     private static $_one_sqrtpi = 0.564189583547756287;

    1887. 

  1887. 

    1888. 

  1888.     private static function _erfcVal($x)

    1889. 

  1889.     {

    1890. 

  1890.         if (abs($x) < 2.2)

    1891. 

  1891.         {

    1892. 

  1892.             return 1 - self :: _erfVal($x);

    1893. 

  1893.         }

    1894. 

  1894.         if ($x < 0)

    1895. 

  1895.         {

    1896. 

  1896.             return 2 - self :: ERFC(- $x);

    1897. 

  1897.         }

    1898. 

  1898.         $a = $n = 1;

    1899. 

  1899.         $b = $c = $x;

    1900. 

  1900.         $d = ($x * $x) + 0.5;

    1901. 

  1901.         $q1 = $q2 = $b / $d;

    1902. 

  1902.         $t = 0;

    1903. 

  1903.         do

    1904. 

  1904.         {

    1905. 

  1905.             $t = $a * $n + $b * $x;

    1906. 

  1906.             $a = $b;

    1907. 

  1907.             $b = $t;

    1908. 

  1908.             $t = $c * $n + $d * $x;

    1909. 

  1909.             $c = $d;

    1910. 

  1910.             $d = $t;

    1911. 

  1911.             $n += 0.5;

    1912. 

  1912.             $q1 = $q2;

    1913. 

  1913.             $q2 = $b / $d;

    1914. 

  1914.         }

    1915. 

  1915.         while ((abs($q1 - $q2) / $q2) > PRECISION);

    1916. 

  1916.         return self :: $_one_sqrtpi * exp(- $x * $x) * $q2;

    1917. 

  1917.     } //	function _erfcVal()
    1918. 

  1918. 

    1919. 

  1919.     

    1920. 

  1920.     /**
    1921. 

  1921.      * ERFC
    1922. 

  1922.      *
    1923. 

  1923.      * Returns the complementary ERF function integrated between x and infinity
    1924. 

  1924.      *
    1925. 

  1925.      * @param	float		$x		The lower bound for integrating ERF
    1926. 

  1926.      * @return	int
    1927. 

  1927.      */

    1928. 

  1928.     public static function ERFC($x)

    1929. 

  1929.     {

    1930. 

  1930.         $x = PHPExcel_Calculation_Functions :: flattenSingleValue($x);

    1931. 

  1931.         

    1932. 

  1932.         if (is_numeric($x))

    1933. 

  1933.         {

    1934. 

  1934.             if ($x < 0)

    1935. 

  1935.             {

    1936. 

  1936.                 return PHPExcel_Calculation_Functions :: NaN();

    1937. 

  1937.             }

    1938. 

  1938.             return self :: _erfcVal($x);

    1939. 

  1939.         }

    1940. 

  1940.         return PHPExcel_Calculation_Functions :: VALUE();

    1941. 

  1941.     } //	function ERFC()
    1942. 

  1942. 

    1943. 

  1943.     

    1944. 

  1944.     /**
    1945. 

  1945.      * getConversionGroups
    1946. 

  1946.      *
    1947. 

  1947.      * @return	array
    1948. 

  1948.      */

    1949. 

  1949.     public static function getConversionGroups()

    1950. 

  1950.     {

    1951. 

  1951.         $conversionGroups = array();

    1952. 

  1952.         foreach (self :: $_conversionUnits as $conversionUnit)

    1953. 

  1953.         {

    1954. 

  1954.             $conversionGroups[] = $conversionUnit['Group'];

    1955. 

  1955.         }

    1956. 

  1956.         return array_merge(array_unique($conversionGroups));

    1957. 

  1957.     } //	function getConversionGroups()
    1958. 

  1958. 

    1959. 

  1959.     

    1960. 

  1960.     /**
    1961. 

  1961.      * getConversionGroupUnits
    1962. 

  1962.      *
    1963. 

  1963.      * @return	array
    1964. 

  1964.      */

    1965. 

  1965.     public static function getConversionGroupUnits($group = NULL)

    1966. 

  1966.     {

    1967. 

  1967.         $conversionGroups = array();

    1968. 

  1968.         foreach (self :: $_conversionUnits as $conversionUnit => $conversionGroup)

    1969. 

  1969.         {

    1970. 

  1970.             if ((is_null($group)) || ($conversionGroup['Group'] == $group))

    1971. 

  1971.             {

    1972. 

  1972.                 $conversionGroups[$conversionGroup['Group']][] = $conversionUnit;

    1973. 

  1973.             }

    1974. 

  1974.         }

    1975. 

  1975.         return $conversionGroups;

    1976. 

  1976.     } //	function getConversionGroupUnits()
    1977. 

  1977. 

    1978. 

  1978.     

    1979. 

  1979.     /**
    1980. 

  1980.      * getConversionGroupUnitDetails
    1981. 

  1981.      *
    1982. 

  1982.      * @return	array
    1983. 

  1983.      */

    1984. 

  1984.     public static function getConversionGroupUnitDetails($group = NULL)

    1985. 

  1985.     {

    1986. 

  1986.         $conversionGroups = array();

    1987. 

  1987.         foreach (self :: $_conversionUnits as $conversionUnit => $conversionGroup)

    1988. 

  1988.         {

    1989. 

  1989.             if ((is_null($group)) || ($conversionGroup['Group'] == $group))

    1990. 

  1990.             {

    1991. 

  1991.                 $conversionGroups[$conversionGroup['Group']][] = array('unit' => $conversionUnit, 

    1992. 

  1992.                         'description' => $conversionGroup['Unit Name']);

    1993. 

  1993.             }

    1994. 

  1994.         }

    1995. 

  1995.         return $conversionGroups;

    1996. 

  1996.     } //	function getConversionGroupUnitDetails()
    1997. 

  1997. 

    1998. 

  1998.     

    1999. 

  1999.     /**
    2000. 

  2000.      * getConversionGroups
    2001. 

  2001.      *
    2002. 

  2002.      * @return	array
    2003. 

  2003.      */

    2004. 

  2004.     public static function getConversionMultipliers()

    2005. 

  2005.     {

    2006. 

  2006.         return self :: $_conversionMultipliers;

    2007. 

  2007.     } //	function getConversionGroups()
    2008. 

  2008. 

    2009. 

  2009.     

    2010. 

  2010.     /**
    2011. 

  2011.      * CONVERTUOM
    2012. 

  2012.      *
    2013. 

  2013.      * @param	float		$value
    2014. 

  2014.      * @param	string		$fromUOM
    2015. 

  2015.      * @param	string		$toUOM
    2016. 

  2016.      * @return	float
    2017. 

  2017.      */

    2018. 

  2018.     public static function CONVERTUOM($value, $fromUOM, $toUOM)

    2019. 

  2019.     {

    2020. 

  2020.         $value = PHPExcel_Calculation_Functions :: flattenSingleValue($value);

    2021. 

  2021.         $fromUOM = PHPExcel_Calculation_Functions :: flattenSingleValue($fromUOM);

    2022. 

  2022.         $toUOM = PHPExcel_Calculation_Functions :: flattenSingleValue($toUOM);

    2023. 

  2023.         

    2024. 

  2024.         if (! is_numeric($value))

    2025. 

  2025.         {

    2026. 

  2026.             return PHPExcel_Calculation_Functions :: VALUE();

    2027. 

  2027.         }

    2028. 

  2028.         $fromMultiplier = 1;

    2029. 

  2029.         if (isset(self :: $_conversionUnits[$fromUOM]))

    2030. 

  2030.         {

    2031. 

  2031.             $unitGroup1 = self :: $_conversionUnits[$fromUOM]['Group'];

    2032. 

  2032.         }

    2033. 

  2033.         else

    2034. 

  2034.         {

    2035. 

  2035.             $fromMultiplier = substr($fromUOM, 0, 1);

    2036. 

  2036.             $fromUOM = substr($fromUOM, 1);

    2037. 

  2037.             if (isset(self :: $_conversionMultipliers[$fromMultiplier]))

    2038. 

  2038.             {

    2039. 

  2039.                 $fromMultiplier = self :: $_conversionMultipliers[$fromMultiplier]['multiplier'];

    2040. 

  2040.             }

    2041. 

  2041.             else

    2042. 

  2042.             {

    2043. 

  2043.                 return PHPExcel_Calculation_Functions :: NA();

    2044. 

  2044.             }

    2045. 

  2045.             if ((isset(self :: $_conversionUnits[$fromUOM])) && (self :: $_conversionUnits[$fromUOM]['AllowPrefix']))

    2046. 

  2046.             {

    2047. 

  2047.                 $unitGroup1 = self :: $_conversionUnits[$fromUOM]['Group'];

    2048. 

  2048.             }

    2049. 

  2049.             else

    2050. 

  2050.             {

    2051. 

  2051.                 return PHPExcel_Calculation_Functions :: NA();

    2052. 

  2052.             }

    2053. 

  2053.         }

    2054. 

  2054.         $value *= $fromMultiplier;

    2055. 

  2055.         

    2056. 

  2056.         $toMultiplier = 1;

    2057. 

  2057.         if (isset(self :: $_conversionUnits[$toUOM]))

    2058. 

  2058.         {

    2059. 

  2059.             $unitGroup2 = self :: $_conversionUnits[$toUOM]['Group'];

    2060. 

  2060.         }

    2061. 

  2061.         else

    2062. 

  2062.         {

    2063. 

  2063.             $toMultiplier = substr($toUOM, 0, 1);

    2064. 

  2064.             $toUOM = substr($toUOM, 1);

    2065. 

  2065.             if (isset(self :: $_conversionMultipliers[$toMultiplier]))

    2066. 

  2066.             {

    2067. 

  2067.                 $toMultiplier = self :: $_conversionMultipliers[$toMultiplier]['multiplier'];

    2068. 

  2068.             }

    2069. 

  2069.             else

    2070. 

  2070.             {

    2071. 

  2071.                 return PHPExcel_Calculation_Functions :: NA();

    2072. 

  2072.             }

    2073. 

  2073.             if ((isset(self :: $_conversionUnits[$toUOM])) && (self :: $_conversionUnits[$toUOM]['AllowPrefix']))

    2074. 

  2074.             {

    2075. 

  2075.                 $unitGroup2 = self :: $_conversionUnits[$toUOM]['Group'];

    2076. 

  2076.             }

    2077. 

  2077.             else

    2078. 

  2078.             {

    2079. 

  2079.                 return PHPExcel_Calculation_Functions :: NA();

    2080. 

  2080.             }

    2081. 

  2081.         }

    2082. 

  2082.         if ($unitGroup1 != $unitGroup2)

    2083. 

  2083.         {

    2084. 

  2084.             return PHPExcel_Calculation_Functions :: NA();

    2085. 

  2085.         }

    2086. 

  2086.         

    2087. 

  2087.         if ($fromUOM == $toUOM)

    2088. 

  2088.         {

    2089. 

  2089.             return 1.0;

    2090. 

  2090.         }

    2091. 

  2091.         elseif ($unitGroup1 == 'Temperature')

    2092. 

  2092.         {

    2093. 

  2093.             if (($fromUOM == 'F') || ($fromUOM == 'fah'))

    2094. 

  2094.             {

    2095. 

  2095.                 if (($toUOM == 'F') || ($toUOM == 'fah'))

    2096. 

  2096.                 {

    2097. 

  2097.                     return 1.0;

    2098. 

  2098.                 }

    2099. 

  2099.                 else

    2100. 

  2100.                 {

    2101. 

  2101.                     $value = (($value - 32) / 1.8);

    2102. 

  2102.                     if (($toUOM == 'K') || ($toUOM == 'kel'))

    2103. 

  2103.                     {

    2104. 

  2104.                         $value += 273.15;

    2105. 

  2105.                     }

    2106. 

  2106.                     return $value;

    2107. 

  2107.                 }

    2108. 

  2108.             }

    2109. 

  2109.             elseif ((($fromUOM == 'K') || ($fromUOM == 'kel')) && (($toUOM == 'K') || ($toUOM == 'kel')))

    2110. 

  2110.             {

    2111. 

  2111.                 return 1.0;

    2112. 

  2112.             }

    2113. 

  2113.             elseif ((($fromUOM == 'C') || ($fromUOM == 'cel')) && (($toUOM == 'C') || ($toUOM == 'cel')))

    2114. 

  2114.             {

    2115. 

  2115.                 return 1.0;

    2116. 

  2116.             }

    2117. 

  2117.             if (($toUOM == 'F') || ($toUOM == 'fah'))

    2118. 

  2118.             {

    2119. 

  2119.                 if (($fromUOM == 'K') || ($fromUOM == 'kel'))

    2120. 

  2120.                 {

    2121. 

  2121.                     $value -= 273.15;

    2122. 

  2122.                 }

    2123. 

  2123.                 return ($value * 1.8) + 32;

    2124. 

  2124.             }

    2125. 

  2125.             if (($toUOM == 'C') || ($toUOM == 'cel'))

    2126. 

  2126.             {

    2127. 

  2127.                 return $value - 273.15;

    2128. 

  2128.             }

    2129. 

  2129.             return $value + 273.15;

    2130. 

  2130.         }

    2131. 

  2131.         return ($value * self :: $_unitConversions[$unitGroup1][$fromUOM][$toUOM]) / $toMultiplier;

    2132. 

  2132.     } //	function CONVERTUOM()
    2133. 

  2133. 

    2134. 

  2134. 

    2135. 

  2135. }	//	class PHPExcel_Calculation_Engineering
    2136. 

  2136.