PageRenderTime 54ms CodeModel.GetById 19ms RepoModel.GetById 0ms app.codeStats 0ms

/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

Large files files are truncated, but you can click here to view the full file

    

  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 :: f…
    995.

Large files files are truncated, but you can click here to view the full file