PageRenderTime 80ms CodeModel.GetById 19ms RepoModel.GetById 1ms app.codeStats 0ms

/protected/extensions/PHPExcel/vendor/PHPExcel/Calculation/Engineering.php

https://bitbucket.org/y_widyatama/ijepa2
PHP | 2505 lines | 1496 code | 210 blank | 799 comment | 317 complexity | 90da5a8f57604b51e8d4f0c6ccf550be MD5 | raw file
Possible License(s): LGPL-2.1, BSD-3-Clause 
    

  1. <?php
    2. 

  2. /**
    3. 

  3.  * PHPExcel
    4. 

  4.  *
    5. 

  5.  * Copyright (c) 2006 - 2014 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 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
    24. 

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

  25.  * @version		##VERSION##, ##DATE##
    26. 

  26.  */
    27. 

  27. 

  28. 

  29. /** PHPExcel root directory */
    30. 

  30. if (!defined('PHPEXCEL_ROOT')) {
    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. 

  39. /** EULER */
    40. 

  40. define('EULER', 2.71828182845904523536);
    41. 

  41. 

  42. 

  43. /**
    44. 

  44.  * PHPExcel_Calculation_Engineering
    45. 

  45.  *
    46. 

  46.  * @category	PHPExcel
    47. 

  47.  * @package		PHPExcel_Calculation
    48. 

  48.  * @copyright	Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
    49. 

  49.  */
    50. 

  50. class PHPExcel_Calculation_Engineering {
    51. 

  51. 

  52. 	/**
    53. 

  53. 	 * Details of the Units of measure that can be used in CONVERTUOM()
    54. 

  54. 	 *
    55. 

  55. 	 * @var mixed[]
    56. 

  56. 	 */
    57. 

  57. 	private static $_conversionUnits = array( 'g'		=> array(	'Group'	=> 'Mass',			'Unit Name'	=> 'Gram',						'AllowPrefix'	=> True		),
    58. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  120. 											);
    121. 

  121. 

  122. 	/**
    123. 

  123. 	 * Details of the Multiplier prefixes that can be used with Units of Measure in CONVERTUOM()
    124. 

  124. 	 *
    125. 

  125. 	 * @var mixed[]
    126. 

  126. 	 */
    127. 

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

  128. 													'Z'	=> array(	'multiplier'	=> 1E21,	'name'	=> 'zetta'	),
    129. 

  129. 													'E'	=> array(	'multiplier'	=> 1E18,	'name'	=> 'exa'	),
    130. 

  130. 													'P'	=> array(	'multiplier'	=> 1E15,	'name'	=> 'peta'	),
    131. 

  131. 													'T'	=> array(	'multiplier'	=> 1E12,	'name'	=> 'tera'	),
    132. 

  132. 													'G'	=> array(	'multiplier'	=> 1E9,		'name'	=> 'giga'	),
    133. 

  133. 													'M'	=> array(	'multiplier'	=> 1E6,		'name'	=> 'mega'	),
    134. 

  134. 													'k'	=> array(	'multiplier'	=> 1E3,		'name'	=> 'kilo'	),
    135. 

  135. 													'h'	=> array(	'multiplier'	=> 1E2,		'name'	=> 'hecto'	),
    136. 

  136. 													'e'	=> array(	'multiplier'	=> 1E1,		'name'	=> 'deka'	),
    137. 

  137. 													'd'	=> array(	'multiplier'	=> 1E-1,	'name'	=> 'deci'	),
    138. 

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

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

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

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

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

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

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

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

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

  147. 												 );
    148. 

  148. 

  149. 	/**
    150. 

  150. 	 * Details of the Units of measure conversion factors, organised by group
    151. 

  151. 	 *
    152. 

  152. 	 * @var mixed[]
    153. 

  153. 	 */
    154. 

  154. 	private static $_unitConversions = array(	'Mass'		=> array(	'g'		=> array(	'g'		=> 1.0,
    155. 

  155. 																							'sg'	=> 6.85220500053478E-05,
    156. 

  156. 																							'lbm'	=> 2.20462291469134E-03,
    157. 

  157. 																							'u'		=> 6.02217000000000E+23,
    158. 

  158. 																							'ozm'	=> 3.52739718003627E-02
    159. 

  159. 																						),
    160. 

  160. 																		'sg'	=> array(	'g'		=> 1.45938424189287E+04,
    161. 

  161. 																							'sg'	=> 1.0,
    162. 

  162. 																							'lbm'	=> 3.21739194101647E+01,
    163. 

  163. 																							'u'		=> 8.78866000000000E+27,
    164. 

  164. 																							'ozm'	=> 5.14782785944229E+02
    165. 

  165. 																						),
    166. 

  166. 																		'lbm'	=> array(	'g'		=> 4.5359230974881148E+02,
    167. 

  167. 																							'sg'	=> 3.10810749306493E-02,
    168. 

  168. 																							'lbm'	=> 1.0,
    169. 

  169. 																							'u'		=> 2.73161000000000E+26,
    170. 

  170. 																							'ozm'	=> 1.60000023429410E+01
    171. 

  171. 																						),
    172. 

  172. 																		'u'		=> array(	'g'		=> 1.66053100460465E-24,
    173. 

  173. 																							'sg'	=> 1.13782988532950E-28,
    174. 

  174. 																							'lbm'	=> 3.66084470330684E-27,
    175. 

  175. 																							'u'		=> 1.0,
    176. 

  176. 																							'ozm'	=> 5.85735238300524E-26
    177. 

  177. 																						),
    178. 

  178. 																		'ozm'	=> array(	'g'		=> 2.83495152079732E+01,
    179. 

  179. 																							'sg'	=> 1.94256689870811E-03,
    180. 

  180. 																							'lbm'	=> 6.24999908478882E-02,
    181. 

  181. 																							'u'		=> 1.70725600000000E+25,
    182. 

  182. 																							'ozm'	=> 1.0
    183. 

  183. 																						)
    184. 

  184. 																	),
    185. 

  185. 												'Distance'	=> array(	'm'		=> array(	'm'		=> 1.0,
    186. 

  186. 																							'mi'	=> 6.21371192237334E-04,
    187. 

  187. 																							'Nmi'	=> 5.39956803455724E-04,
    188. 

  188. 																							'in'	=> 3.93700787401575E+01,
    189. 

  189. 																							'ft'	=> 3.28083989501312E+00,
    190. 

  190. 																							'yd'	=> 1.09361329797891E+00,
    191. 

  191. 																							'ang'	=> 1.00000000000000E+10,
    192. 

  192. 																							'Pica'	=> 2.83464566929116E+03
    193. 

  193. 																						),
    194. 

  194. 																		'mi'	=> array(	'm'		=> 1.60934400000000E+03,
    195. 

  195. 																							'mi'	=> 1.0,
    196. 

  196. 																							'Nmi'	=> 8.68976241900648E-01,
    197. 

  197. 																							'in'	=> 6.33600000000000E+04,
    198. 

  198. 																							'ft'	=> 5.28000000000000E+03,
    199. 

  199. 																							'yd'	=> 1.76000000000000E+03,
    200. 

  200. 																							'ang'	=> 1.60934400000000E+13,
    201. 

  201. 																							'Pica'	=> 4.56191999999971E+06
    202. 

  202. 																						),
    203. 

  203. 																		'Nmi'	=> array(	'm'		=> 1.85200000000000E+03,
    204. 

  204. 																							'mi'	=> 1.15077944802354E+00,
    205. 

  205. 																							'Nmi'	=> 1.0,
    206. 

  206. 																							'in'	=> 7.29133858267717E+04,
    207. 

  207. 																							'ft'	=> 6.07611548556430E+03,
    208. 

  208. 																							'yd'	=> 2.02537182785694E+03,
    209. 

  209. 																							'ang'	=> 1.85200000000000E+13,
    210. 

  210. 																							'Pica'	=> 5.24976377952723E+06
    211. 

  211. 																						),
    212. 

  212. 																		'in'	=> array(	'm'		=> 2.54000000000000E-02,
    213. 

  213. 																							'mi'	=> 1.57828282828283E-05,
    214. 

  214. 																							'Nmi'	=> 1.37149028077754E-05,
    215. 

  215. 																							'in'	=> 1.0,
    216. 

  216. 																							'ft'	=> 8.33333333333333E-02,
    217. 

  217. 																							'yd'	=> 2.77777777686643E-02,
    218. 

  218. 																							'ang'	=> 2.54000000000000E+08,
    219. 

  219. 																							'Pica'	=> 7.19999999999955E+01
    220. 

  220. 																						),
    221. 

  221. 																		'ft'	=> array(	'm'		=> 3.04800000000000E-01,
    222. 

  222. 																							'mi'	=> 1.89393939393939E-04,
    223. 

  223. 																							'Nmi'	=> 1.64578833693305E-04,
    224. 

  224. 																							'in'	=> 1.20000000000000E+01,
    225. 

  225. 																							'ft'	=> 1.0,
    226. 

  226. 																							'yd'	=> 3.33333333223972E-01,
    227. 

  227. 																							'ang'	=> 3.04800000000000E+09,
    228. 

  228. 																							'Pica'	=> 8.63999999999946E+02
    229. 

  229. 																						),
    230. 

  230. 																		'yd'	=> array(	'm'		=> 9.14400000300000E-01,
    231. 

  231. 																							'mi'	=> 5.68181818368230E-04,
    232. 

  232. 																							'Nmi'	=> 4.93736501241901E-04,
    233. 

  233. 																							'in'	=> 3.60000000118110E+01,
    234. 

  234. 																							'ft'	=> 3.00000000000000E+00,
    235. 

  235. 																							'yd'	=> 1.0,
    236. 

  236. 																							'ang'	=> 9.14400000300000E+09,
    237. 

  237. 																							'Pica'	=> 2.59200000085023E+03
    238. 

  238. 																						),
    239. 

  239. 																		'ang'	=> array(	'm'		=> 1.00000000000000E-10,
    240. 

  240. 																							'mi'	=> 6.21371192237334E-14,
    241. 

  241. 																							'Nmi'	=> 5.39956803455724E-14,
    242. 

  242. 																							'in'	=> 3.93700787401575E-09,
    243. 

  243. 																							'ft'	=> 3.28083989501312E-10,
    244. 

  244. 																							'yd'	=> 1.09361329797891E-10,
    245. 

  245. 																							'ang'	=> 1.0,
    246. 

  246. 																							'Pica'	=> 2.83464566929116E-07
    247. 

  247. 																						),
    248. 

  248. 																		'Pica'	=> array(	'm'		=> 3.52777777777800E-04,
    249. 

  249. 																							'mi'	=> 2.19205948372629E-07,
    250. 

  250. 																							'Nmi'	=> 1.90484761219114E-07,
    251. 

  251. 																							'in'	=> 1.38888888888898E-02,
    252. 

  252. 																							'ft'	=> 1.15740740740748E-03,
    253. 

  253. 																							'yd'	=> 3.85802469009251E-04,
    254. 

  254. 																							'ang'	=> 3.52777777777800E+06,
    255. 

  255. 																							'Pica'	=> 1.0
    256. 

  256. 																						)
    257. 

  257. 																	),
    258. 

  258. 												'Time'		=> array(	'yr'	=> array(	'yr'		=> 1.0,
    259. 

  259. 																							'day'		=> 365.25,
    260. 

  260. 																							'hr'		=> 8766.0,
    261. 

  261. 																							'mn'		=> 525960.0,
    262. 

  262. 																							'sec'		=> 31557600.0
    263. 

  263. 																						),
    264. 

  264. 																		'day'	=> array(	'yr'		=> 2.73785078713210E-03,
    265. 

  265. 																							'day'		=> 1.0,
    266. 

  266. 																							'hr'		=> 24.0,
    267. 

  267. 																							'mn'		=> 1440.0,
    268. 

  268. 																							'sec'		=> 86400.0
    269. 

  269. 																						),
    270. 

  270. 																		'hr'	=> array(	'yr'		=> 1.14077116130504E-04,
    271. 

  271. 																							'day'		=> 4.16666666666667E-02,
    272. 

  272. 																							'hr'		=> 1.0,
    273. 

  273. 																							'mn'		=> 60.0,
    274. 

  274. 																							'sec'		=> 3600.0
    275. 

  275. 																						),
    276. 

  276. 																		'mn'	=> array(	'yr'		=> 1.90128526884174E-06,
    277. 

  277. 																							'day'		=> 6.94444444444444E-04,
    278. 

  278. 																							'hr'		=> 1.66666666666667E-02,
    279. 

  279. 																							'mn'		=> 1.0,
    280. 

  280. 																							'sec'		=> 60.0
    281. 

  281. 																						),
    282. 

  282. 																		'sec'	=> array(	'yr'		=> 3.16880878140289E-08,
    283. 

  283. 																							'day'		=> 1.15740740740741E-05,
    284. 

  284. 																							'hr'		=> 2.77777777777778E-04,
    285. 

  285. 																							'mn'		=> 1.66666666666667E-02,
    286. 

  286. 																							'sec'		=> 1.0
    287. 

  287. 																						)
    288. 

  288. 																	),
    289. 

  289. 												'Pressure'	=> array(	'Pa'	=> array(	'Pa'		=> 1.0,
    290. 

  290. 																							'p'			=> 1.0,
    291. 

  291. 																							'atm'		=> 9.86923299998193E-06,
    292. 

  292. 																							'at'		=> 9.86923299998193E-06,
    293. 

  293. 																							'mmHg'		=> 7.50061707998627E-03
    294. 

  294. 																						),
    295. 

  295. 																		'p'		=> array(	'Pa'		=> 1.0,
    296. 

  296. 																							'p'			=> 1.0,
    297. 

  297. 																							'atm'		=> 9.86923299998193E-06,
    298. 

  298. 																							'at'		=> 9.86923299998193E-06,
    299. 

  299. 																							'mmHg'		=> 7.50061707998627E-03
    300. 

  300. 																						),
    301. 

  301. 																		'atm'	=> array(	'Pa'		=> 1.01324996583000E+05,
    302. 

  302. 																							'p'			=> 1.01324996583000E+05,
    303. 

  303. 																							'atm'		=> 1.0,
    304. 

  304. 																							'at'		=> 1.0,
    305. 

  305. 																							'mmHg'		=> 760.0
    306. 

  306. 																						),
    307. 

  307. 																		'at'	=> array(	'Pa'		=> 1.01324996583000E+05,
    308. 

  308. 																							'p'			=> 1.01324996583000E+05,
    309. 

  309. 																							'atm'		=> 1.0,
    310. 

  310. 																							'at'		=> 1.0,
    311. 

  311. 																							'mmHg'		=> 760.0
    312. 

  312. 																						),
    313. 

  313. 																		'mmHg'	=> array(	'Pa'		=> 1.33322363925000E+02,
    314. 

  314. 																							'p'			=> 1.33322363925000E+02,
    315. 

  315. 																							'atm'		=> 1.31578947368421E-03,
    316. 

  316. 																							'at'		=> 1.31578947368421E-03,
    317. 

  317. 																							'mmHg'		=> 1.0
    318. 

  318. 																						)
    319. 

  319. 																	),
    320. 

  320. 												'Force'		=> array(	'N'		=> array(	'N'			=> 1.0,
    321. 

  321. 																							'dyn'		=> 1.0E+5,
    322. 

  322. 																							'dy'		=> 1.0E+5,
    323. 

  323. 																							'lbf'		=> 2.24808923655339E-01
    324. 

  324. 																						),
    325. 

  325. 																		'dyn'	=> array(	'N'			=> 1.0E-5,
    326. 

  326. 																							'dyn'		=> 1.0,
    327. 

  327. 																							'dy'		=> 1.0,
    328. 

  328. 																							'lbf'		=> 2.24808923655339E-06
    329. 

  329. 																						),
    330. 

  330. 																		'dy'	=> array(	'N'			=> 1.0E-5,
    331. 

  331. 																							'dyn'		=> 1.0,
    332. 

  332. 																							'dy'		=> 1.0,
    333. 

  333. 																							'lbf'		=> 2.24808923655339E-06
    334. 

  334. 																						),
    335. 

  335. 																		'lbf'	=> array(	'N'			=> 4.448222,
    336. 

  336. 																							'dyn'		=> 4.448222E+5,
    337. 

  337. 																							'dy'		=> 4.448222E+5,
    338. 

  338. 																							'lbf'		=> 1.0
    339. 

  339. 																						)
    340. 

  340. 																	),
    341. 

  341. 												'Energy'	=> array(	'J'		=> array(	'J'			=> 1.0,
    342. 

  342. 																							'e'			=> 9.99999519343231E+06,
    343. 

  343. 																							'c'			=> 2.39006249473467E-01,
    344. 

  344. 																							'cal'		=> 2.38846190642017E-01,
    345. 

  345. 																							'eV'		=> 6.24145700000000E+18,
    346. 

  346. 																							'ev'		=> 6.24145700000000E+18,
    347. 

  347. 																							'HPh'		=> 3.72506430801000E-07,
    348. 

  348. 																							'hh'		=> 3.72506430801000E-07,
    349. 

  349. 																							'Wh'		=> 2.77777916238711E-04,
    350. 

  350. 																							'wh'		=> 2.77777916238711E-04,
    351. 

  351. 																							'flb'		=> 2.37304222192651E+01,
    352. 

  352. 																							'BTU'		=> 9.47815067349015E-04,
    353. 

  353. 																							'btu'		=> 9.47815067349015E-04
    354. 

  354. 																						),
    355. 

  355. 																		'e'		=> array(	'J'			=> 1.00000048065700E-07,
    356. 

  356. 																							'e'			=> 1.0,
    357. 

  357. 																							'c'			=> 2.39006364353494E-08,
    358. 

  358. 																							'cal'		=> 2.38846305445111E-08,
    359. 

  359. 																							'eV'		=> 6.24146000000000E+11,
    360. 

  360. 																							'ev'		=> 6.24146000000000E+11,
    361. 

  361. 																							'HPh'		=> 3.72506609848824E-14,
    362. 

  362. 																							'hh'		=> 3.72506609848824E-14,
    363. 

  363. 																							'Wh'		=> 2.77778049754611E-11,
    364. 

  364. 																							'wh'		=> 2.77778049754611E-11,
    365. 

  365. 																							'flb'		=> 2.37304336254586E-06,
    366. 

  366. 																							'BTU'		=> 9.47815522922962E-11,
    367. 

  367. 																							'btu'		=> 9.47815522922962E-11
    368. 

  368. 																						),
    369. 

  369. 																		'c'		=> array(	'J'			=> 4.18399101363672E+00,
    370. 

  370. 																							'e'			=> 4.18398900257312E+07,
    371. 

  371. 																							'c'			=> 1.0,
    372. 

  372. 																							'cal'		=> 9.99330315287563E-01,
    373. 

  373. 																							'eV'		=> 2.61142000000000E+19,
    374. 

  374. 																							'ev'		=> 2.61142000000000E+19,
    375. 

  375. 																							'HPh'		=> 1.55856355899327E-06,
    376. 

  376. 																							'hh'		=> 1.55856355899327E-06,
    377. 

  377. 																							'Wh'		=> 1.16222030532950E-03,
    378. 

  378. 																							'wh'		=> 1.16222030532950E-03,
    379. 

  379. 																							'flb'		=> 9.92878733152102E+01,
    380. 

  380. 																							'BTU'		=> 3.96564972437776E-03,
    381. 

  381. 																							'btu'		=> 3.96564972437776E-03
    382. 

  382. 																						),
    383. 

  383. 																		'cal'	=> array(	'J'			=> 4.18679484613929E+00,
    384. 

  384. 																							'e'			=> 4.18679283372801E+07,
    385. 

  385. 																							'c'			=> 1.00067013349059E+00,
    386. 

  386. 																							'cal'		=> 1.0,
    387. 

  387. 																							'eV'		=> 2.61317000000000E+19,
    388. 

  388. 																							'ev'		=> 2.61317000000000E+19,
    389. 

  389. 																							'HPh'		=> 1.55960800463137E-06,
    390. 

  390. 																							'hh'		=> 1.55960800463137E-06,
    391. 

  391. 																							'Wh'		=> 1.16299914807955E-03,
    392. 

  392. 																							'wh'		=> 1.16299914807955E-03,
    393. 

  393. 																							'flb'		=> 9.93544094443283E+01,
    394. 

  394. 																							'BTU'		=> 3.96830723907002E-03,
    395. 

  395. 																							'btu'		=> 3.96830723907002E-03
    396. 

  396. 																						),
    397. 

  397. 																		'eV'	=> array(	'J'			=> 1.60219000146921E-19,
    398. 

  398. 																							'e'			=> 1.60218923136574E-12,
    399. 

  399. 																							'c'			=> 3.82933423195043E-20,
    400. 

  400. 																							'cal'		=> 3.82676978535648E-20,
    401. 

  401. 																							'eV'		=> 1.0,
    402. 

  402. 																							'ev'		=> 1.0,
    403. 

  403. 																							'HPh'		=> 5.96826078912344E-26,
    404. 

  404. 																							'hh'		=> 5.96826078912344E-26,
    405. 

  405. 																							'Wh'		=> 4.45053000026614E-23,
    406. 

  406. 																							'wh'		=> 4.45053000026614E-23,
    407. 

  407. 																							'flb'		=> 3.80206452103492E-18,
    408. 

  408. 																							'BTU'		=> 1.51857982414846E-22,
    409. 

  409. 																							'btu'		=> 1.51857982414846E-22
    410. 

  410. 																						),
    411. 

  411. 																		'ev'	=> array(	'J'			=> 1.60219000146921E-19,
    412. 

  412. 																							'e'			=> 1.60218923136574E-12,
    413. 

  413. 																							'c'			=> 3.82933423195043E-20,
    414. 

  414. 																							'cal'		=> 3.82676978535648E-20,
    415. 

  415. 																							'eV'		=> 1.0,
    416. 

  416. 																							'ev'		=> 1.0,
    417. 

  417. 																							'HPh'		=> 5.96826078912344E-26,
    418. 

  418. 																							'hh'		=> 5.96826078912344E-26,
    419. 

  419. 																							'Wh'		=> 4.45053000026614E-23,
    420. 

  420. 																							'wh'		=> 4.45053000026614E-23,
    421. 

  421. 																							'flb'		=> 3.80206452103492E-18,
    422. 

  422. 																							'BTU'		=> 1.51857982414846E-22,
    423. 

  423. 																							'btu'		=> 1.51857982414846E-22
    424. 

  424. 																						),
    425. 

  425. 																		'HPh'	=> array(	'J'			=> 2.68451741316170E+06,
    426. 

  426. 																							'e'			=> 2.68451612283024E+13,
    427. 

  427. 																							'c'			=> 6.41616438565991E+05,
    428. 

  428. 																							'cal'		=> 6.41186757845835E+05,
    429. 

  429. 																							'eV'		=> 1.67553000000000E+25,
    430. 

  430. 																							'ev'		=> 1.67553000000000E+25,
    431. 

  431. 																							'HPh'		=> 1.0,
    432. 

  432. 																							'hh'		=> 1.0,
    433. 

  433. 																							'Wh'		=> 7.45699653134593E+02,
    434. 

  434. 																							'wh'		=> 7.45699653134593E+02,
    435. 

  435. 																							'flb'		=> 6.37047316692964E+07,
    436. 

  436. 																							'BTU'		=> 2.54442605275546E+03,
    437. 

  437. 																							'btu'		=> 2.54442605275546E+03
    438. 

  438. 																						),
    439. 

  439. 																		'hh'	=> array(	'J'			=> 2.68451741316170E+06,
    440. 

  440. 																							'e'			=> 2.68451612283024E+13,
    441. 

  441. 																							'c'			=> 6.41616438565991E+05,
    442. 

  442. 																							'cal'		=> 6.41186757845835E+05,
    443. 

  443. 																							'eV'		=> 1.67553000000000E+25,
    444. 

  444. 																							'ev'		=> 1.67553000000000E+25,
    445. 

  445. 																							'HPh'		=> 1.0,
    446. 

  446. 																							'hh'		=> 1.0,
    447. 

  447. 																							'Wh'		=> 7.45699653134593E+02,
    448. 

  448. 																							'wh'		=> 7.45699653134593E+02,
    449. 

  449. 																							'flb'		=> 6.37047316692964E+07,
    450. 

  450. 																							'BTU'		=> 2.54442605275546E+03,
    451. 

  451. 																							'btu'		=> 2.54442605275546E+03
    452. 

  452. 																						),
    453. 

  453. 																		'Wh'	=> array(	'J'			=> 3.59999820554720E+03,
    454. 

  454. 																							'e'			=> 3.59999647518369E+10,
    455. 

  455. 																							'c'			=> 8.60422069219046E+02,
    456. 

  456. 																							'cal'		=> 8.59845857713046E+02,
    457. 

  457. 																							'eV'		=> 2.24692340000000E+22,
    458. 

  458. 																							'ev'		=> 2.24692340000000E+22,
    459. 

  459. 																							'HPh'		=> 1.34102248243839E-03,
    460. 

  460. 																							'hh'		=> 1.34102248243839E-03,
    461. 

  461. 																							'Wh'		=> 1.0,
    462. 

  462. 																							'wh'		=> 1.0,
    463. 

  463. 																							'flb'		=> 8.54294774062316E+04,
    464. 

  464. 																							'BTU'		=> 3.41213254164705E+00,
    465. 

  465. 																							'btu'		=> 3.41213254164705E+00
    466. 

  466. 																						),
    467. 

  467. 																		'wh'	=> array(	'J'			=> 3.59999820554720E+03,
    468. 

  468. 																							'e'			=> 3.59999647518369E+10,
    469. 

  469. 																							'c'			=> 8.60422069219046E+02,
    470. 

  470. 																							'cal'		=> 8.59845857713046E+02,
    471. 

  471. 																							'eV'		=> 2.24692340000000E+22,
    472. 

  472. 																							'ev'		=> 2.24692340000000E+22,
    473. 

  473. 																							'HPh'		=> 1.34102248243839E-03,
    474. 

  474. 																							'hh'		=> 1.34102248243839E-03,
    475. 

  475. 																							'Wh'		=> 1.0,
    476. 

  476. 																							'wh'		=> 1.0,
    477. 

  477. 																							'flb'		=> 8.54294774062316E+04,
    478. 

  478. 																							'BTU'		=> 3.41213254164705E+00,
    479. 

  479. 																							'btu'		=> 3.41213254164705E+00
    480. 

  480. 																						),
    481. 

  481. 																		'flb'	=> array(	'J'			=> 4.21400003236424E-02,
    482. 

  482. 																							'e'			=> 4.21399800687660E+05,
    483. 

  483. 																							'c'			=> 1.00717234301644E-02,
    484. 

  484. 																							'cal'		=> 1.00649785509554E-02,
    485. 

  485. 																							'eV'		=> 2.63015000000000E+17,
    486. 

  486. 																							'ev'		=> 2.63015000000000E+17,
    487. 

  487. 																							'HPh'		=> 1.56974211145130E-08,
    488. 

  488. 																							'hh'		=> 1.56974211145130E-08,
    489. 

  489. 																							'Wh'		=> 1.17055614802000E-05,
    490. 

  490. 																							'wh'		=> 1.17055614802000E-05,
    491. 

  491. 																							'flb'		=> 1.0,
    492. 

  492. 																							'BTU'		=> 3.99409272448406E-05,
    493. 

  493. 																							'btu'		=> 3.99409272448406E-05
    494. 

  494. 																						),
    495. 

  495. 																		'BTU'	=> array(	'J'			=> 1.05505813786749E+03,
    496. 

  496. 																							'e'			=> 1.05505763074665E+10,
    497. 

  497. 																							'c'			=> 2.52165488508168E+02,
    498. 

  498. 																							'cal'		=> 2.51996617135510E+02,
    499. 

  499. 																							'eV'		=> 6.58510000000000E+21,
    500. 

  500. 																							'ev'		=> 6.58510000000000E+21,
    501. 

  501. 																							'HPh'		=> 3.93015941224568E-04,
    502. 

  502. 																							'hh'		=> 3.93015941224568E-04,
    503. 

  503. 																							'Wh'		=> 2.93071851047526E-01,
    504. 

  504. 																							'wh'		=> 2.93071851047526E-01,
    505. 

  505. 																							'flb'		=> 2.50369750774671E+04,
    506. 

  506. 																							'BTU'		=> 1.0,
    507. 

  507. 																							'btu'		=> 1.0,
    508. 

  508. 																						),
    509. 

  509. 																		'btu'	=> array(	'J'			=> 1.05505813786749E+03,
    510. 

  510. 																							'e'			=> 1.05505763074665E+10,
    511. 

  511. 																							'c'			=> 2.52165488508168E+02,
    512. 

  512. 																							'cal'		=> 2.51996617135510E+02,
    513. 

  513. 																							'eV'		=> 6.58510000000000E+21,
    514. 

  514. 																							'ev'		=> 6.58510000000000E+21,
    515. 

  515. 																							'HPh'		=> 3.93015941224568E-04,
    516. 

  516. 																							'hh'		=> 3.93015941224568E-04,
    517. 

  517. 																							'Wh'		=> 2.93071851047526E-01,
    518. 

  518. 																							'wh'		=> 2.93071851047526E-01,
    519. 

  519. 																							'flb'		=> 2.50369750774671E+04,
    520. 

  520. 																							'BTU'		=> 1.0,
    521. 

  521. 																							'btu'		=> 1.0,
    522. 

  522. 																						)
    523. 

  523. 																	),
    524. 

  524. 												'Power'		=> array(	'HP'	=> array(	'HP'		=> 1.0,
    525. 

  525. 																							'h'			=> 1.0,
    526. 

  526. 																							'W'			=> 7.45701000000000E+02,
    527. 

  527. 																							'w'			=> 7.45701000000000E+02
    528. 

  528. 																						),
    529. 

  529. 																		'h'		=> array(	'HP'		=> 1.0,
    530. 

  530. 																							'h'			=> 1.0,
    531. 

  531. 																							'W'			=> 7.45701000000000E+02,
    532. 

  532. 																							'w'			=> 7.45701000000000E+02
    533. 

  533. 																						),
    534. 

  534. 																		'W'		=> array(	'HP'		=> 1.34102006031908E-03,
    535. 

  535. 																							'h'			=> 1.34102006031908E-03,
    536. 

  536. 																							'W'			=> 1.0,
    537. 

  537. 																							'w'			=> 1.0
    538. 

  538. 																						),
    539. 

  539. 																		'w'		=> array(	'HP'		=> 1.34102006031908E-03,
    540. 

  540. 																							'h'			=> 1.34102006031908E-03,
    541. 

  541. 																							'W'			=> 1.0,
    542. 

  542. 																							'w'			=> 1.0
    543. 

  543. 																						)
    544. 

  544. 																	),
    545. 

  545. 												'Magnetism'	=> array(	'T'		=> array(	'T'			=> 1.0,
    546. 

  546. 																							'ga'		=> 10000.0
    547. 

  547. 																						),
    548. 

  548. 																		'ga'	=> array(	'T'			=> 0.0001,
    549. 

  549. 																							'ga'		=> 1.0
    550. 

  550. 																						)
    551. 

  551. 																	),
    552. 

  552. 												'Liquid'	=> array(	'tsp'	=> array(	'tsp'		=> 1.0,
    553. 

  553. 																							'tbs'		=> 3.33333333333333E-01,
    554. 

  554. 																							'oz'		=> 1.66666666666667E-01,
    555. 

  555. 																							'cup'		=> 2.08333333333333E-02,
    556. 

  556. 																							'pt'		=> 1.04166666666667E-02,
    557. 

  557. 																							'us_pt'		=> 1.04166666666667E-02,
    558. 

  558. 																							'uk_pt'		=> 8.67558516821960E-03,
    559. 

  559. 																							'qt'		=> 5.20833333333333E-03,
    560. 

  560. 																							'gal'		=> 1.30208333333333E-03,
    561. 

  561. 																							'l'			=> 4.92999408400710E-03,
    562. 

  562. 																							'lt'		=> 4.92999408400710E-03
    563. 

  563. 																						),
    564. 

  564. 																		'tbs'	=> array(	'tsp'		=> 3.00000000000000E+00,
    565. 

  565. 																							'tbs'		=> 1.0,
    566. 

  566. 																							'oz'		=> 5.00000000000000E-01,
    567. 

  567. 																							'cup'		=> 6.25000000000000E-02,
    568. 

  568. 																							'pt'		=> 3.12500000000000E-02,
    569. 

  569. 																							'us_pt'		=> 3.12500000000000E-02,
    570. 

  570. 																							'uk_pt'		=> 2.60267555046588E-02,
    571. 

  571. 																							'qt'		=> 1.56250000000000E-02,
    572. 

  572. 																							'gal'		=> 3.90625000000000E-03,
    573. 

  573. 																							'l'			=> 1.47899822520213E-02,
    574. 

  574. 																							'lt'		=> 1.47899822520213E-02
    575. 

  575. 																						),
    576. 

  576. 																		'oz'	=> array(	'tsp'		=> 6.00000000000000E+00,
    577. 

  577. 																							'tbs'		=> 2.00000000000000E+00,
    578. 

  578. 																							'oz'		=> 1.0,
    579. 

  579. 																							'cup'		=> 1.25000000000000E-01,
    580. 

  580. 																							'pt'		=> 6.25000000000000E-02,
    581. 

  581. 																							'us_pt'		=> 6.25000000000000E-02,
    582. 

  582. 																							'uk_pt'		=> 5.20535110093176E-02,
    583. 

  583. 																							'qt'		=> 3.12500000000000E-02,
    584. 

  584. 																							'gal'		=> 7.81250000000000E-03,
    585. 

  585. 																							'l'			=> 2.95799645040426E-02,
    586. 

  586. 																							'lt'		=> 2.95799645040426E-02
    587. 

  587. 																						),
    588. 

  588. 																		'cup'	=> array(	'tsp'		=> 4.80000000000000E+01,
    589. 

  589. 																							'tbs'		=> 1.60000000000000E+01,
    590. 

  590. 																							'oz'		=> 8.00000000000000E+00,
    591. 

  591. 																							'cup'		=> 1.0,
    592. 

  592. 																							'pt'		=> 5.00000000000000E-01,
    593. 

  593. 																							'us_pt'		=> 5.00000000000000E-01,
    594. 

  594. 																							'uk_pt'		=> 4.16428088074541E-01,
    595. 

  595. 																							'qt'		=> 2.50000000000000E-01,
    596. 

  596. 																							'gal'		=> 6.25000000000000E-02,
    597. 

  597. 																							'l'			=> 2.36639716032341E-01,
    598. 

  598. 																							'lt'		=> 2.36639716032341E-01
    599. 

  599. 																						),
    600. 

  600. 																		'pt'	=> array(	'tsp'		=> 9.60000000000000E+01,
    601. 

  601. 																							'tbs'		=> 3.20000000000000E+01,
    602. 

  602. 																							'oz'		=> 1.60000000000000E+01,
    603. 

  603. 																							'cup'		=> 2.00000000000000E+00,
    604. 

  604. 																							'pt'		=> 1.0,
    605. 

  605. 																							'us_pt'		=> 1.0,
    606. 

  606. 																							'uk_pt'		=> 8.32856176149081E-01,
    607. 

  607. 																							'qt'		=> 5.00000000000000E-01,
    608. 

  608. 																							'gal'		=> 1.25000000000000E-01,
    609. 

  609. 																							'l'			=> 4.73279432064682E-01,
    610. 

  610. 																							'lt'		=> 4.73279432064682E-01
    611. 

  611. 																						),
    612. 

  612. 																		'us_pt'	=> array(	'tsp'		=> 9.60000000000000E+01,
    613. 

  613. 																							'tbs'		=> 3.20000000000000E+01,
    614. 

  614. 																							'oz'		=> 1.60000000000000E+01,
    615. 

  615. 																							'cup'		=> 2.00000000000000E+00,
    616. 

  616. 																							'pt'		=> 1.0,
    617. 

  617. 																							'us_pt'		=> 1.0,
    618. 

  618. 																							'uk_pt'		=> 8.32856176149081E-01,
    619. 

  619. 																							'qt'		=> 5.00000000000000E-01,
    620. 

  620. 																							'gal'		=> 1.25000000000000E-01,
    621. 

  621. 																							'l'			=> 4.73279432064682E-01,
    622. 

  622. 																							'lt'		=> 4.73279432064682E-01
    623. 

  623. 																						),
    624. 

  624. 																		'uk_pt'	=> array(	'tsp'		=> 1.15266000000000E+02,
    625. 

  625. 																							'tbs'		=> 3.84220000000000E+01,
    626. 

  626. 																							'oz'		=> 1.92110000000000E+01,
    627. 

  627. 																							'cup'		=> 2.40137500000000E+00,
    628. 

  628. 																							'pt'		=> 1.20068750000000E+00,
    629. 

  629. 																							'us_pt'		=> 1.20068750000000E+00,
    630. 

  630. 																							'uk_pt'		=> 1.0,
    631. 

  631. 																							'qt'		=> 6.00343750000000E-01,
    632. 

  632. 																							'gal'		=> 1.50085937500000E-01,
    633. 

  633. 																							'l'			=> 5.68260698087162E-01,
    634. 

  634. 																							'lt'		=> 5.68260698087162E-01
    635. 

  635. 																						),
    636. 

  636. 																		'qt'	=> array(	'tsp'		=> 1.92000000000000E+02,
    637. 

  637. 																							'tbs'		=> 6.40000000000000E+01,
    638. 

  638. 																							'oz'		=> 3.20000000000000E+01,
    639. 

  639. 																							'cup'		=> 4.00000000000000E+00,
    640. 

  640. 																							'pt'		=> 2.00000000000000E+00,
    641. 

  641. 																							'us_pt'		=> 2.00000000000000E+00,
    642. 

  642. 																							'uk_pt'		=> 1.66571235229816E+00,
    643. 

  643. 																							'qt'		=> 1.0,
    644. 

  644. 																							'gal'		=> 2.50000000000000E-01,
    645. 

  645. 																							'l'			=> 9.46558864129363E-01,
    646. 

  646. 																							'lt'		=> 9.46558864129363E-01
    647. 

  647. 																						),
    648. 

  648. 																		'gal'	=> array(	'tsp'		=> 7.68000000000000E+02,
    649. 

  649. 																							'tbs'		=> 2.56000000000000E+02,
    650. 

  650. 																							'oz'		=> 1.28000000000000E+02,
    651. 

  651. 																							'cup'		=> 1.60000000000000E+01,
    652. 

  652. 																							'pt'		=> 8.00000000000000E+00,
    653. 

  653. 																							'us_pt'		=> 8.00000000000000E+00,
    654. 

  654. 																							'uk_pt'		=> 6.66284940919265E+00,
    655. 

  655. 																							'qt'		=> 4.00000000000000E+00,
    656. 

  656. 																							'gal'		=> 1.0,
    657. 

  657. 																							'l'			=> 3.78623545651745E+00,
    658. 

  658. 																							'lt'		=> 3.78623545651745E+00
    659. 

  659. 																						),
    660. 

  660. 																		'l'		=> array(	'tsp'		=> 2.02840000000000E+02,
    661. 

  661. 																							'tbs'		=> 6.76133333333333E+01,
    662. 

  662. 																							'oz'		=> 3.38066666666667E+01,
    663. 

  663. 																							'cup'		=> 4.22583333333333E+00,
    664. 

  664. 																							'pt'		=> 2.11291666666667E+00,
    665. 

  665. 																							'us_pt'		=> 2.11291666666667E+00,
    666. 

  666. 																							'uk_pt'		=> 1.75975569552166E+00,
    667. 

  667. 																							'qt'		=> 1.05645833333333E+00,
    668. 

  668. 																							'gal'		=> 2.64114583333333E-01,
    669. 

  669. 																							'l'			=> 1.0,
    670. 

  670. 																							'lt'		=> 1.0
    671. 

  671. 																						),
    672. 

  672. 																		'lt'	=> array(	'tsp'		=> 2.02840000000000E+02,
    673. 

  673. 																							'tbs'		=> 6.76133333333333E+01,
    674. 

  674. 																							'oz'		=> 3.38066666666667E+01,
    675. 

  675. 																							'cup'		=> 4.22583333333333E+00,
    676. 

  676. 																							'pt'		=> 2.11291666666667E+00,
    677. 

  677. 																							'us_pt'		=> 2.11291666666667E+00,
    678. 

  678. 																							'uk_pt'		=> 1.75975569552166E+00,
    679. 

  679. 																							'qt'		=> 1.05645833333333E+00,
    680. 

  680. 																							'gal'		=> 2.64114583333333E-01,
    681. 

  681. 																							'l'			=> 1.0,
    682. 

  682. 																							'lt'		=> 1.0
    683. 

  683. 																						)
    684. 

  684. 																	)
    685. 

  685. 											);
    686. 

  686. 

  687. 

  688. 	/**
    689. 

  689. 	 * _parseComplex
    690. 

  690. 	 *
    691. 

  691. 	 * Parses a complex number into its real and imaginary parts, and an I or J suffix
    692. 

  692. 	 *
    693. 

  693. 	 * @param	string		$complexNumber	The complex number
    694. 

  694. 	 * @return	string[]	Indexed on "real", "imaginary" and "suffix"
    695. 

  695. 	 */
    696. 

  696. 	public static function _parseComplex($complexNumber) {
    697. 

  697. 		$workString = (string) $complexNumber;
    698. 

  698. 

  699. 		$realNumber = $imaginary = 0;
    700. 

  700. 		//	Extract the suffix, if there is one
    701. 

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

  702. 		if (!is_numeric($suffix)) {
    703. 

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

  704. 		} else {
    705. 

  705. 			$suffix = '';
    706. 

  706. 		}
    707. 

  707. 

  708. 		//	Split the input into its Real and Imaginary components
    709. 

  709. 		$leadingSign = 0;
    710. 

  710. 		if (strlen($workString) > 0) {
    711. 

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

  712. 		}
    713. 

  713. 		$power = '';
    714. 

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

  715. 		if (strtoupper(substr($realNumber,-1)) == 'E') {
    716. 

  716. 			$power = strtok('+-');
    717. 

  717. 			++$leadingSign;
    718. 

  718. 		}
    719. 

  719. 

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

  721. 

  722. 		if ($suffix != '') {
    723. 

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

  724. 

  725. 			if (($imaginary == '') && (($realNumber == '') || ($realNumber == '+') || ($realNumber == '-'))) {
    726. 

  726. 				$imaginary = $realNumber.'1';
    727. 

  727. 				$realNumber = '0';
    728. 

  728. 			} else if ($imaginary == '') {
    729. 

  729. 				$imaginary = $realNumber;
    730. 

  730. 				$realNumber = '0';
    731. 

  731. 			} elseif (($imaginary == '+') || ($imaginary == '-')) {
    732. 

  732. 				$imaginary .= '1';
    733. 

  733. 			}
    734. 

  734. 		}
    735. 

  735. 

  736. 		return array( 'real'		=> $realNumber,
    737. 

  737. 					  'imaginary'	=> $imaginary,
    738. 

  738. 					  'suffix'		=> $suffix
    739. 

  739. 					);
    740. 

  740. 	}	//	function _parseComplex()
    741. 

  741. 

  742. 

  743. 	/**
    744. 

  744. 	 * Cleans the leading characters in a complex number string
    745. 

  745. 	 *
    746. 

  746. 	 * @param	string		$complexNumber	The complex number to clean
    747. 

  747. 	 * @return	string		The "cleaned" complex number
    748. 

  748. 	 */
    749. 

  749. 	private static function _cleanComplex($complexNumber) {
    750. 

  750. 		if ($complexNumber{0} == '+') $complexNumber = substr($complexNumber,1);
    751. 

  751. 		if ($complexNumber{0} == '0') $complexNumber = substr($complexNumber,1);
    752. 

  752. 		if ($complexNumber{0} == '.') $complexNumber = '0'.$complexNumber;
    753. 

  753. 		if ($complexNumber{0} == '+') $complexNumber = substr($complexNumber,1);
    754. 

  754. 		return $complexNumber;
    755. 

  755. 	}
    756. 

  756. 

  757. 	/**
    758. 

  758. 	 * Formats a number base string value with leading zeroes
    759. 

  759. 	 *
    760. 

  760. 	 * @param	string		$xVal		The "number" to pad
    761. 

  761. 	 * @param	integer		$places		The length that we want to pad this value
    762. 

  762. 	 * @return	string		The padded "number"
    763. 

  763. 	 */
    764. 

  764. 	private static function _nbrConversionFormat($xVal, $places) {
    765. 

  765. 		if (!is_null($places)) {
    766. 

  766. 			if (strlen($xVal) <= $places) {
    767. 

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

  768. 			} else {
    769. 

  769. 				return PHPExcel_Calculation_Functions::NaN();
    770. 

  770. 			}
    771. 

  771. 		}
    772. 

  772. 

  773. 		return substr($xVal, -10);
    774. 

  774. 	}	//	function _nbrConversionFormat()
    775. 

  775. 

  776. 	/**
    777. 

  777. 	 *	BESSELI
    778. 

  778. 	 *
    779. 

  779. 	 *	Returns the modified Bessel function In(x), which is equivalent to the Bessel function evaluated
    780. 

  780. 	 *		for purely imaginary arguments
    781. 

  781. 	 *
    782. 

  782. 	 *	Excel Function:
    783. 

  783. 	 *		BESSELI(x,ord)
    784. 

  784. 	 *
    785. 

  785. 	 *	@access	public
    786. 

  786. 	 *	@category Engineering Functions
    787. 

  787. 	 *	@param	float		$x		The value at which to evaluate the function.
    788. 

  788. 	 *								If x is nonnumeric, BESSELI returns the #VALUE! error value.
    789. 

  789. 	 *	@param	integer		$ord	The order of the Bessel function.
    790. 

  790. 	 *								If ord is not an integer, it is truncated.
    791. 

  791. 	 *								If $ord is nonnumeric, BESSELI returns the #VALUE! error value.
    792. 

  792. 	 *								If $ord < 0, BESSELI returns the #NUM! error value.
    793. 

  793. 	 *	@return	float
    794. 

  794. 	 *
    795. 

  795. 	 */
    796. 

  796. 	public static function BESSELI($x, $ord) {
    797. 

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

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

  799. 

  800. 		if ((is_numeric($x)) && (is_numeric($ord))) {
    801. 

  801. 			$ord	= floor($ord);
    802. 

  802. 			if ($ord < 0) {
    803. 

  803. 				return PHPExcel_Calculation_Functions::NaN();
    804. 

  804. 			}
    805. 

  805. 

  806. 			if (abs($x) <= 30) {
    807. 

  807. 				$fResult = $fTerm = pow($x / 2, $ord) / PHPExcel_Calculation_MathTrig::FACT($ord);
    808. 

  808. 				$ordK = 1;
    809. 

  809. 				$fSqrX = ($x * $x) / 4;
    810. 

  810. 				do {
    811. 

  811. 					$fTerm *= $fSqrX;
    812. 

  812. 					$fTerm /= ($ordK * ($ordK + $ord));
    813. 

  813. 					$fResult += $fTerm;
    814. 

  814. 				} while ((abs($fTerm) > 1e-12) && (++$ordK < 100));
    815. 

  815. 			} else {
    816. 

  816. 				$f_2_PI = 2 * M_PI;
    817. 

  817. 

  818. 				$fXAbs = abs($x);
    819. 

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

  820. 				if (($ord & 1) && ($x < 0)) {
    821. 

  821. 					$fResult = -$fResult;
    822. 

  822. 				}
    823. 

  823. 			}
    824. 

  824. 			return (is_nan($fResult)) ? PHPExcel_Calculation_Functions::NaN() : $fResult;
    825. 

  825. 		}
    826. 

  826. 		return PHPExcel_Calculation_Functions::VALUE();
    827. 

  827. 	}	//	function BESSELI()
    828. 

  828. 

  829. 

  830. 	/**
    831. 

  831. 	 *	BESSELJ
    832. 

  832. 	 *
    833. 

  833. 	 *	Returns the Bessel function
    834. 

  834. 	 *
    835. 

  835. 	 *	Excel Function:
    836. 

  836. 	 *		BESSELJ(x,ord)
    837. 

  837. 	 *
    838. 

  838. 	 *	@access	public
    839. 

  839. 	 *	@category Engineering Functions
    840. 

  840. 	 *	@param	float		$x		The value at which to evaluate the function.
    841. 

  841. 	 *								If x is nonnumeric, BESSELJ returns the #VALUE! error value.
    842. 

  842. 	 *	@param	integer		$ord	The order of the Bessel function. If n is not an integer, it is truncated.
    843. 

  843. 	 *								If $ord is nonnumeric, BESSELJ returns the #VALUE! error value.
    844. 

  844. 	 *								If $ord < 0, BESSELJ returns the #NUM! error value.
    845. 

  845. 	 *	@return	float
    846. 

  846. 	 *
    847. 

  847. 	 */
    848. 

  848. 	public static function BESSELJ($x, $ord) {
    849. 

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

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

  851. 

  852. 		if ((is_numeric($x)) && (is_numeric($ord))) {
    853. 

  853. 			$ord	= floor($ord);
    854. 

  854. 			if ($ord < 0) {
    855. 

  855. 				return PHPExcel_Calculation_Functions::NaN();
    856. 

  856. 			}
    857. 

  857. 

  858. 			$fResult = 0;
    859. 

  859. 			if (abs($x) <= 30) {
    860. 

  860. 				$fResult = $fTerm = pow($x / 2, $ord) / PHPExcel_Calculation_MathTrig::FACT($ord);
    861. 

  861. 				$ordK = 1;
    862. 

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

  863. 				do {
    864. 

  864. 					$fTerm *= $fSqrX;
    865. 

  865. 					$fTerm /= ($ordK * ($ordK + $ord));
    866. 

  866. 					$fResult += $fTerm;
    867. 

  867. 				} while ((abs($fTerm) > 1e-12) && (++$ordK < 100));
    868. 

  868. 			} else {
    869. 

  869. 				$f_PI_DIV_2 = M_PI / 2;
    870. 

  870. 				$f_PI_DIV_4 = M_PI / 4;
    871. 

  871. 

  872. 				$fXAbs = abs($x);
    873. 

  873. 				$fResult = sqrt(M_2DIVPI / $fXAbs) * cos($fXAbs - $ord * $f_PI_DIV_2 - $f_PI_DIV_4);
    874. 

  874. 				if (($ord & 1) && ($x < 0)) {
    875. 

  875. 					$fResult = -$fResult;
    876. 

  876. 				}
    877. 

  877. 			}
    878. 

  878. 			return (is_nan($fResult)) ? PHPExcel_Calculation_Functions::NaN() : $fResult;
    879. 

  879. 		}
    880. 

  880. 		return PHPExcel_Calculation_Functions::VALUE();
    881. 

  881. 	}	//	function BESSELJ()
    882. 

  882. 

  883. 

  884. 	private static function _Besselk0($fNum) {
    885. 

  885. 		if ($fNum <= 2) {
    886. 

  886. 			$fNum2 = $fNum * 0.5;
    887. 

  887. 			$y = ($fNum2 * $fNum2);
    888. 

  888. 			$fRet = -log($fNum2) * self::BESSELI($fNum, 0) +
    889. 

  889. 					(-0.57721566 + $y * (0.42278420 + $y * (0.23069756 + $y * (0.3488590e-1 + $y * (0.262698e-2 + $y *
    890. 

  890. 					(0.10750e-3 + $y * 0.74e-5))))));
    891. 

  891. 		} else {
    892. 

  892. 			$y = 2 / $fNum;
    893. 

  893. 			$fRet = exp(-$fNum) / sqrt($fNum) *
    894. 

  894. 					(1.25331414 + $y * (-0.7832358e-1 + $y * (0.2189568e-1 + $y * (-0.1062446e-1 + $y *
    895. 

  895. 					(0.587872e-2 + $y * (-0.251540e-2 + $y * 0.53208e-3))))));
    896. 

  896. 		}
    897. 

  897. 		return $fRet;
    898. 

  898. 	}	//	function _Besselk0()
    899. 

  899. 

  900. 

  901. 	private static function _Besselk1($fNum) {
    902. 

  902. 		if ($fNum <= 2) {
    903. 

  903. 			$fNum2 = $fNum * 0.5;
    904. 

  904. 			$y = ($fNum2 * $fNum2);
    905. 

  905. 			$fRet = log($fNum2) * self::BESSELI($fNum, 1) +
    906. 

  906. 					(1 + $y * (0.15443144 + $y * (-0.67278579 + $y * (-0.18156897 + $y * (-0.1919402e-1 + $y *
    907. 

  907. 					(-0.110404e-2 + $y * (-0.4686e-4))))))) / $fNum;
    908. 

  908. 		} else {
    909. 

  909. 			$y = 2 / $fNum;
    910. 

  910. 			$fRet = exp(-$fNum) / sqrt($fNum) *
    911. 

  911. 					(1.25331414 + $y * (0.23498619 + $y * (-0.3655620e-1 + $y * (0.1504268e-1 + $y * (-0.780353e-2 + $y *
    912. 

  912. 					(0.325614e-2 + $y * (-0.68245e-3)))))));
    913. 

  913. 		}
    914. 

  914. 		return $fRet;
    915. 

  915. 	}	//	function _Besselk1()
    916. 

  916. 

  917. 

  918. 	/**
    919. 

  919. 	 *	BESSELK
    920. 

  920. 	 *
    921. 

  921. 	 *	Returns the modified Bessel function Kn(x), which is equivalent to the Bessel functions evaluated
    922. 

  922. 	 *		for purely imaginary arguments.
    923. 

  923. 	 *
    924. 

  924. 	 *	Excel Function:
    925. 

  925. 	 *		BESSELK(x,ord)
    926. 

  926. 	 *
    927. 

  927. 	 *	@access	public
    928. 

  928. 	 *	@category Engineering Functions
    929. 

  929. 	 *	@param	float		$x		The value at which to evaluate the function.
    930. 

  930. 	 *								If x is nonnumeric, BESSELK returns the #VALUE! error value.
    931. 

  931. 	 *	@param	integer		$ord	The order of the Bessel function. If n is not an integer, it is truncated.
    932. 

  932. 	 *								If $ord is nonnumeric, BESSELK returns the #VALUE! error value.
    933. 

  933. 	 *								If $ord < 0, BESSELK returns the #NUM! error value.
    934. 

  934. 	 *	@return	float
    935. 

  935. 	 *
    936. 

  936. 	 */
    937. 

  937. 	public static function BESSELK($x, $ord) {
    938. 

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

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

  940. 

  941. 		if ((is_numeric($x)) && (is_numeric($ord))) {
    942. 

  942. 			if (($ord < 0) || ($x == 0.0)) {
    943. 

  943. 				return PHPExcel_Calculation_Functions::NaN();
    944. 

  944. 			}
    945. 

  945. 

  946. 			switch(floor($ord)) {
    947. 

  947. 				case 0 :	return self::_Besselk0($x);
    948. 

  948. 							break;
    949. 

  949. 				case 1 :	return self::_Besselk1($x);
    950. 

  950. 							break;
    951. 

  951. 				default :	$fTox	= 2 / $x;
    952. 

  952. 							$fBkm	= self::_Besselk0($x);
    953. 

  953. 							$fBk	= self::_Besselk1($x);
    954. 

  954. 							for ($n = 1; $n < $ord; ++$n) {
    955. 

  955. 								$fBkp	= $fBkm + $n * $fTox * $fBk;
    956. 

  956. 								$fBkm	= $fBk;
    957. 

  957. 								$fBk	= $fBkp;
    958. 

  958. 							}
    959. 

  959. 			}
    960. 

  960. 			return (is_nan($fBk)) ? PHPExcel_Calculation_Functions::NaN() : $fBk;
    961. 

  961. 		}
    962. 

  962. 		return PHPExcel_Calculation_Functions::VALUE();
    963. 

  963. 	}	//	function BESSELK()
    964. 

  964. 

  965. 

  966. 	private static function _Bessely0($fNum) {
    967. 

  967. 		if ($fNum < 8.0) {
    968. 

  968. 			$y = ($fNum * $fNum);
    969. 

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

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

  971. 			$fRet = $f1 / $f2 + 0.636619772 * self::BESSELJ($fNum, 0) * log($fNum);
    972. 

  972. 		} else {
    973. 

  973. 			$z = 8.0 / $fNum;
    974. 

  974. 			$y = ($z * $z);
    975. 

  975. 			$xx = $fNum - 0.785398164;
    976. 

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

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

  978. 			$fRet = sqrt(0.636619772 / $fNum) * (sin($xx) * $f1 + $z * cos($xx) * $f2);
    979. 

  979. 		}
    980. 

  980. 		return $fRet;
    981. 

  981. 	}	//	function _Bessely0()
    982. 

  982. 

  983. 

  984. 	private static function _Bessely1($fNum) {
    985. 

  985. 		if ($fNum < 8.0) {
    986. 

  986. 			$y = ($fNum * $fNum);
    987. 

  987. 			$f1 = $fNum * (-0.4900604943e13 + $y * (0.1275274390e13 + $y * (-0.5153438139e11 + $y * (0.7349264551e9 + $y *
    988. 

  988. 				(-0.4237922726e7 + $y * 0.8511937935e4)))));
    989. 

  989. 			$f2 = 0.2499580570e14 + $y * (0.4244419664e12 + $y * (0.3733650367e10 + $y * (0.2245904002e8 + $y *
    990. 

  990. 				(0.1020426050e6 + $y * (0.3549632885e3 + $y)))));
    991. 

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

  992. 		} else {
    993. 

  993. 			$fRet = sqrt(0.636619772 / $fNum) * sin($fNum - 2.356194491);
    994. 

  994. 		}
    995. 

  995. 		return $fRet;
    996. 

  996. 	}	//	function _Bessely1()
    997. 

  997. 

  998. 

  999. 	/**
    1000. 

  1000. 	 *	BESSELY
    1001. 

  1001. 	 *
    1002. 

  1002. 	 *	Returns the Bessel function, which is also called the Weber function or the Neumann function.
    1003. 

  1003. 	 *
    1004. 

  1004. 	 *	Excel Function:
    1005. 

  1005. 	 *		BESSELY(x,ord)
    1006. 

  1006. 	 *
    1007. 

  1007. 	 *	@access	public
    1008. 

  1008. 	 *	@category Engineering Functions
    1009. 

  1009. 	 *	@param	float		$x		The value at which to evaluate the function.
    1010. 

  1010. 	 *								If x is nonnumeric, BESSELK returns the #VALUE! error value.
    1011. 

  1011. 	 *	@param	integer		$ord	The order of the Bessel function. If n is not an integer, it is truncated.
    1012. 

  1012. 	 *								If $ord is nonnumeric, BESSELK returns the #VALUE! error value.
    1013. 

  1013. 	 *								If $ord < 0, BESSELK returns the #NUM! error value.
    1014. 

  1014. 	 *
    1015. 

  1015. 	 *	@return	float
    1016. 

  1016. 	 */
    1017. 

  1017. 	public static function BESSELY($x, $ord) {
    1018. 

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

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

  1020. 

  1021. 		if ((is_numeric($x)) && (is_numeric($ord))) {
    1022. 

  1022. 			if (($ord < 0) || ($x == 0.0)) {
    1023. 

  1023. 				return PHPExcel_Calculation_Functions::NaN();
    1024. 

  1024. 			}
    1025. 

  1025. 

  1026. 			switch(floor($ord)) {
    1027. 

  1027. 				case 0 :	return self::_Bessely0($x);
    1028. 

  1028. 							break;
    1029. 

  1029. 				case 1 :	return self::_Bessely1($x);
    1030. 

  1030. 							break;
    1031. 

  1031. 				default:	$fTox	= 2 / $x;
    1032. 

  1032. 							$fBym	= self::_Bessely0($x);
    1033. 

  1033. 							$fBy	= self::_Bessely1($x);
    1034. 

  1034. 							for ($n = 1; $n < $ord; ++$n) {
    1035. 

  1035. 								$fByp	= $n * $fTox * $fBy - $fBym;
    1036. 

  1036. 								$fBym	= $fBy;
    1037. 

  1037. 								$fBy	= $fByp;
    1038. 

  1038. 							}
    1039. 

  1039. 			}
    1040. 

  1040. 			return (is_nan($fBy)) ? PHPExcel_Calculation_Functions::NaN() : $fBy;
    1041. 

  1041. 		}
    1042. 

  1042. 		return PHPExcel_Calculation_Functions::VALUE();
    1043. 

  1043. 	}	//	function BESSELY()
    1044. 

  1044. 

  1045. 

  1046. 	/**
    1047. 

  1047. 	 * BINTODEC
    1048. 

  1048. 	 *
    1049. 

  1049. 	 * Return a binary value as decimal.
    1050. 

  1050. 	 *
    1051. 

  1051. 	 * Excel Function:
    1052. 

  1052. 	 *		BIN2DEC(x)
    1053. 

  1053. 	 *
    1054. 

  1054. 	 * @access	public
    1055. 

  1055. 	 * @category Engineering Functions
    1056. 

  1056. 	 * @param	string		$x		The binary number (as a string) that you want to convert. The number
    1057. 

  1057. 	 *								cannot contain more than 10 characters (10 bits). The most significant
    1058. 

  1058. 	 *								bit of number is the sign bit. The remaining 9 bits are magnitude bits.
    1059. 

  1059. 	 *								Negative numbers are represented using two's-complement notation.
    1060. 

  1060. 	 *								If number is not a valid binary number, or if number contains more than
    1061. 

  1061. 	 *								10 characters (10 bits), BIN2DEC returns the #NUM! error value.
    1062. 

  1062. 	 * @return	string
    1063. 

  1063. 	 */
    1064. 

  1064. 	public static function BINTODEC($x) {
    1065. 

  1065. 		$x	= PHPExcel_Calculation_Functions::flattenSingleValue($x);
    1066. 

  1066. 

  1067. 		if (is_bool($x)) {
    1068. 

  1068. 			if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE) {
    1069. 

  1069. 				$x = (int) $x;
    1070. 

  1070. 			} else {
    1071. 

  1071. 				return PHPExcel_Calculation_Functions::VALUE();
    1072. 

  1072. 			}
    1073. 

  1073. 		}
    1074. 

  1074. 		if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC) {
    1075. 

  1075. 			$x = floor($x);
    1076. 

  1076. 		}
    1077. 

  1077. 		$x = (string) $x;
    1078. 

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

  1079. 			return PHPExcel_Calculation_Functions::NaN();
    1080. 

  1080. 		}
    1081. 

  1081. 		if (strlen($x) > 10) {
    1082. 

  1082. 			return PHPExcel_Calculation_Functions::NaN();
    1083. 

  1083. 		} elseif (strlen($x) == 10) {
    1084. 

  1084. 			//	Two's Complement
    1085. 

  1085. 			$x = substr($x,-9);
    1086. 

  1086. 			return '-'.(512-bindec($x));
    1087. 

  1087. 		}
    1088. 

  1088. 		return bindec($x);
    1089. 

  1089. 	}	//	function BINTODEC()
    1090. 

  1090. 

  1091. 

  1092. 	/**
    1093. 

  1093. 	 * BINTOHEX
    1094. 

  1094. 	 *
    1095. 

  1095. 	 * Return a binary value as hex.
    1096. 

  1096. 	 *
    1097. 

  1097. 	 * Excel Function:
    1098. 

  1098. 	 *		BIN2HEX(x[,places])
    1099. 

  1099. 	 *
    1100. 

  1100. 	 * @access	public
    1101. 

  1101. 	 * @category Engineering Functions
    1102. 

  1102. 	 * @param	string		$x		The binary number (as a string) that you want to convert. The number
    1103. 

  1103. 	 *								cannot contain more than 10 characters (10 bits). The most significant
    1104. 

  1104. 	 *								bit of number is the sign bit. The remaining 9 bits are magnitude bits.
    1105. 

  1105. 	 *								Negative numbers are represented using two's-complement notation.
    1106. 

  1106. 	 *								If number is not a valid binary number, or if number contains more than
    1107. 

  1107. 	 *								10 characters (10 bits), BIN2HEX returns the #NUM! error value.
    1108. 

  1108. 	 * @param	integer		$places	The number of characters to use. If places is omitted, BIN2HEX uses the
    1109. 

  1109. 	 *								minimum number of characters necessary. Places is useful for padding the
    1110. 

  1110. 	 *								return value with leading 0s (zeros).
    1111. 

  1111. 	 *								If places is not an integer, it is truncated.
    1112. 

  1112. 	 *								If places is nonnumeric, BIN2HEX returns the #VALUE! error value.
    1113. 

  1113. 	 *								If places is negative, BIN2HEX returns the #NUM! error value.
    1114. 

  1114. 	 * @return	string
    1115. 

  1115. 	 */
    1116. 

  1116. 	public static function BINTOHEX($x, $places=NULL) {
    1117. 

  1117. 		$x	= PHPExcel_Calculation_Functions::flattenSingleValue($x);
    1118. 

  1118. 		$places	= PHPExcel_Calculation_Functions::flattenSingleValue($places);
    1119. 

  1119. 

  1120. 		if (is_bool($x)) {
    1121. 

  1121. 			if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE) {
    1122. 

  1122. 				$x = (int) $x;
    1123. 

  1123. 			} else {
    1124. 

  1124. 				return PHPExcel_Calculation_Functions::VALUE();
    1125. 

  1125. 			}
    1126. 

  1126. 		}
    1127. 

  1127. 		if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC) {
    1128. 

  1128. 			$x = floor($x);
    1129. 

  1129. 		}
    1130. 

  1130. 		$x = (string) $x;
    1131. 

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

  1132. 			return PHPExcel_Calculation_Functions::NaN();
    1133. 

  1133. 		}
    1134. 

  1134. 		if (strlen($x) > 10) {
    1135. 

  1135. 			return PHPExcel_Calculation_Functions::NaN();
    1136. 

  1136. 		} elseif (strlen($x) == 10) {
    1137. 

  1137. 			//	Two's Complement
    1138. 

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

  1139. 		}
    1140. 

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

  1141. 

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

  1143. 	}	//	function BINTOHEX()
    1144. 

  1144. 

  1145. 

  1146. 	/**
    1147. 

  1147. 	 * BINTOOCT
    1148. 

  1148. 	 *
    1149. 

  1149. 	 * Return a binary value as octal.
    1150. 

  1150. 	 *
    1151. 

  1151. 	 * Excel Function:
    1152. 

  1152. 	 *		BIN2OCT(x[,places])
    1153. 

  1153. 	 *
    1154. 

  1154. 	 * @access	public
    1155. 

  1155. 	 * @category Engineering Functions
    1156. 

  1156. 	 * @param	string		$x		The binary number (as a string) that you want to convert. The number
    1157. 

  1157. 	 *								cannot contain more than 10 characters (10 bits). The most significant
    1158. 

  1158. 	 *								bit of number is the sign bit. The remaining 9 bits are magnitude bits.
    1159. 

  1159. 	 *								Negative numbers are represented using two's-complement notation.
    1160. 

  1160. 	 *								If number is not a valid binary number, or if number contains more than
    1161. 

  1161. 	 *								10 characters (10 bits), BIN2OCT returns the #NUM! error value.
    1162. 

  1162. 	 * @param	integer		$places	The number of characters to use. If places is omitted, BIN2OCT uses the
    1163. 

  1163. 	 *								minimum number of characters necessary. Places is useful for padding the
    1164. 

  1164. 	 *								return value with leading 0s (zeros).
    1165. 

  1165. 	 *								If places is not an integer, it is truncated.
    1166. 

  1166. 	 *								If places is nonnumeric, BIN2OCT returns the #VALUE! error value.
    1167. 

  1167. 	 *								If places is negative, BIN2OCT returns the #NUM! error value.
    1168. 

  1168. 	 * @return	string
    1169. 

  1169. 	 */
    1170. 

  1170. 	public static function BINTOOCT($x, $places=NULL) {
    1171. 

  1171. 		$x	= PHPExcel_Calculation_Functions::flattenSingleValue($x);
    1172. 

  1172. 		$places	= PHPExcel_Calculation_Functions::flattenSingleValue($places);
    1173. 

  1173. 

  1174. 		if (is_bool($x)) {
    1175. 

  1175. 			if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE) {
    1176. 

  1176. 				$x = (int) $x;
    1177. 

  1177. 			} else {
    1178. 

  1178. 				return PHPExcel_Calculation_Functions::VALUE();
    1179. 

  1179. 			}
    1180. 

  1180. 		}
    1181. 

  1181. 		if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC) {
    1182. 

  1182. 			$x = floor($x);
    1183. 

  1183. 		}
    1184. 

  1184. 		$x = (string) $x;
    1185. 

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

  1186. 			return PHPExcel_Calculation_Functions::NaN();
    1187. 

  1187. 		}
    1188. 

  1188. 		if (strlen($x) > 10) {
    1189. 

  1189. 			return PHPExcel_Calculation_Functions::NaN();
    1190. 

  1190. 		} elseif (strlen($x) == 10) {
    1191. 

  1191. 			//	Two's Complement
    1192. 

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

  1193. 		}
    1194. 

  1194. 		$octVal = (string) decoct(bindec($x));
    1195. 

  1195. 

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

  1197. 	}	//	function BINTOOCT()
    1198. 

  1198. 

  1199. 

  1200. 	/**
    1201. 

  1201. 	 * DECTOBIN
    1202. 

  1202. 	 *
    1203. 

  1203. 	 * Return a decimal value as binary.
    1204. 

  1204. 	 *
    1205. 

  1205. 	 * Excel Function:
    1206. 

  1206. 	 *		DEC2BIN(x[,places])
    1207. 

  1207. 	 *
    1208. 

  1208. 	 * @access	public
    1209. 

  1209. 	 * @category Engineering Functions
    1210. 

  1210. 	 * @param	string		$x		The decimal integer you want to convert. If number is negative,
    1211. 

  1211. 	 *								valid place values are ignored and DEC2BIN returns a 10-character
    1212. 

  1212. 	 *								(10-bit) binary number in which the most significant bit is the sign
    1213. 

  1213. 	 *								bit. The remaining 9 bits are magnitude bits. Negative numbers are
    1214. 

  1214. 	 *								represented using two's-complement notation.
    1215. 

  1215. 	 *								If number < -512 or if number > 511, DEC2BIN returns the #NUM! error
    1216. 

  1216. 	 *								value.
    1217. 

  1217. 	 *								If number is nonnumeric, DEC2BIN returns the #VALUE! error value.
    1218. 

  1218. 	 *								If DEC2BIN requires more than places characters, it returns the #NUM!
    1219. 

  1219. 	 *								error value.
    1220. 

  1220. 	 * @param	integer		$places	The number of characters to use. If places is omitted, DEC2BIN uses
    1221. 

  1221. 	 *								the minimum number of characters necessary. Places is useful for
    1222. 

  1222. 	 *								padding the return value with leading 0s (zeros).
    1223. 

  1223. 	 *								If places is not an integer, it is truncated.
    1224. 

  1224. 	 *								If places is nonnumeric, DEC2BIN returns the #VALUE! error value.
    1225. 

  1225. 	 *								If places is zero or negative, DEC2BIN returns the #NUM! error value.
    1226. 

  1226. 	 * @return	string
    1227. 

  1227. 	 */
    1228. 

  1228. 	public static function DECTOBIN($x, $places=NULL) {
    1229. 

  1229. 		$x	= PHPExcel_Calculation_Functions::flattenSingleValue($x);
    1230. 

  1230. 		$places	= PHPExcel_Calculation_Functions::flattenSingleValue($places);
    1231. 

  1231. 

  1232. 		if (is_bool($x)) {
    1233. 

  1233. 			if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE) {
    1234. 

  1234. 				$x = (int) $x;
    1235. 

  1235. 			} else {
    1236. 

  1236. 				return PHPExcel_Calculation_Functions::VALUE();
    1237. 

  1237. 			}
    1238. 

  1238. 		}
    1239. 

  1239. 		$x = (string) $x;
    1240. 

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

  1241. 			return PHPExcel_Calculation_Functions::VALUE();
    1242. 

  1242. 		}
    1243. 

  1243. 		$x = (string) floor($x);
    1244. 

  1244. 		$r = decbin($x);
    1245. 

  1245. 		if (strlen($r) == 32) {
    1246. 

  1246. 			//	Two's Complement
    1247. 

  1247. 			$r = substr($r,-10);
    1248. 

  1248. 		} elseif (strlen($r) > 11) {
    1249. 

  1249. 			return PHPExcel_Calculation_Functions::NaN();
    1250. 

  1250. 		}
    1251. 

  1251. 

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

  1253. 	}	//	function DECTOBIN()
    1254. 

  1254. 

  1255. 

  1256. 	/**
    1257. 

  1257. 	 * DECTOHEX
    1258. 

  1258. 	 *
    1259. 

  1259. 	 * Return a decimal value as hex.
    1260. 

  1260. 	 *
    1261. 

  1261. 	 * Excel Function:
    1262. 

  1262. 	 *		DEC2HEX(x[,places])
    1263. 

  1263. 	 *
    1264. 

  1264. 	 * @access	public
    1265. 

  1265. 	 * @category Engineering Functions
    1266. 

  1266. 	 * @param	string		$x		The decimal integer you want to convert. If number is negative,
    1267. 

  1267. 	 *								places is ignored and DEC2HEX returns a 10-character (40-bit)
    1268. 

  1268. 	 *								hexadecimal number in which the most significant bit is the sign
    1269. 

  1269. 	 *								bit. The remaining 39 bits are magnitude bits. Negative numbers
    1270. 

  1270. 	 *								are represented using two's-complement notation.
    1271. 

  1271. 	 *								If number < -549,755,813,888 or if number > 549,755,813,887,
    1272. 

  1272. 	 *								DEC2HEX returns the #NUM! error value.
    1273. 

  1273. 	 *								If number is nonnumeric, DEC2HEX returns the #VALUE! error value.
    1274. 

  1274. 	 *								If DEC2HEX requires more than places characters, it returns the
    1275. 

  1275. 	 *								#NUM! error value.
    1276. 

  1276. 	 * @param	integer		$places	The number of characters to use. If places is omitted, DEC2HEX uses
    1277. 

  1277. 	 *								the minimum number of characters necessary. Places is useful for
    1278. 

  1278. 	 *								padding the return value with leading 0s (zeros).
    1279. 

  1279. 	 *								If places is not an integer, it is truncated.
    1280. 

  1280. 	 *								If places is nonnumeric, DEC2HEX returns the #VALUE! error value.
    1281. 

  1281. 	 *								If places is zero or negative, DEC2HEX returns the #NUM! error value.
    1282. 

  1282. 	 * @return	string
    1283. 

  1283. 	 */
    1284. 

  1284. 	public static function DECTOHEX($x, $places=null) {
    1285. 

  1285. 		$x	= PHPExcel_Calculation_Functions::flattenSingleValue($x);
    1286. 

  1286. 		$places	= PHPExcel_Calculation_Functions::flattenSingleValue($places);
    1287. 

  1287. 

  1288. 		if (is_bool($x)) {
    1289. 

  1289. 			if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE) {
    1290. 

  1290. 				$x = (int) $x;
    1291. 

  1291. 			} else {
    1292. 

  1292. 				return PHPExcel_Calculation_Functions::VALUE();
    1293. 

  1293. 			}
    1294. 

  1294. 		}
    1295. 

  1295. 		$x = (string) $x;
    1296. 

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

  1297. 			return PHPExcel_Calculation_Functions::VALUE();
    1298. 

  1298. 		}
    1299. 

  1299. 		$x = (string) floor($x);
    1300. 

  1300. 		$r = strtoupper(dechex($x));
    1301. 

  1301. 		if (strlen($r) == 8) {
    1302. 

  1302. 			//	Two's Complement
    1303. 

  1303. 			$r = 'FF'.$r;
    1304. 

  1304. 		}
    1305. 

  1305. 

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

  1307. 	}	//	function DECTOHEX()
    1308. 

  1308. 

  1309. 

  1310. 	/**
    1311. 

  1311. 	 * DECTOOCT
    1312. 

  1312. 	 *
    1313. 

  1313. 	 * Return an decimal value as octal.
    1314. 

  1314. 	 *
    1315. 

  1315. 	 * Excel Function:
    1316. 

  1316. 	 *		DEC2OCT(x[,places])
    1317. 

  1317. 	 *
    1318. 

  1318. 	 * @access	public
    1319. 

  1319. 	 * @category Engineering Functions
    1320. 

  1320. 	 * @param	string		$x		The decimal integer you want to convert. If number is negative,
    1321. 

  1321. 	 *								places is ignored and DEC2OCT returns a 10-character (30-bit)
    1322. 

  1322. 	 *								octal number in which the most significant bit is the sign bit.
    1323. 

  1323. 	 *								The remaining 29 bits are magnitude bits. Negative numbers are
    1324. 

  1324. 	 *								represented using two's-complement notation.
    1325. 

  1325. 	 *								If number < -536,870,912 or if number > 536,870,911, DEC2OCT
    1326. 

  1326. 	 *								returns the #NUM! error value.
    1327. 

  1327. 	 *								If number is nonnumeric, DEC2OCT returns the #VALUE! error value.
    1328. 

  1328. 	 *								If DEC2OCT requires more than places characters, it returns the
    1329. 

  1329. 	 *								#NUM! error value.
    1330. 

  1330. 	 * @param	integer		$places	The number of characters to use. If places is omitted, DEC2OCT uses
    1331. 

  1331. 	 *								the minimum number of characters necessary. Places is useful for
    1332. 

  1332. 	 *								padding the return value with leading 0s (zeros).
    1333. 

  1333. 	 *								If places is not an integer, it is truncated.
    1334. 

  1334. 	 *								If places is nonnumeric, DEC2OCT returns the #VALUE! error value.
    1335. 

  1335. 	 *								If places is zero or negative, DEC2OCT returns the #NUM! error value.
    1336. 

  1336. 	 * @return	string
    1337. 

  1337. 	 */
    1338. 

  1338. 	public static function DECTOOCT($x, $places=null) {
    1339. 

  1339. 		$x	= PHPExcel_Calculation_Functions::flattenSingleValue($x);
    1340. 

  1340. 		$places	= PHPExcel_Calculation_Functions::flattenSingleValue($places);
    1341. 

  1341. 

  1342. 		if (is_bool($x)) {
    1343. 

  1343. 			if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE) {
    1344. 

  1344. 				$x = (int) $x;
    1345. 

  1345. 			} else {
    1346. 

  1346. 				return PHPExcel_Calculation_Functions::VALUE();
    1347. 

  1347. 			}
    1348. 

  1348. 		}
    1349. 

  1349. 		$x = (string) $x;
    1350. 

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

  1351. 			return PHPExcel_Calculation_Functions::VALUE();
    1352. 

  1352. 		}
    1353. 

  1353. 		$x = (string) floor($x);
    1354. 

  1354. 		$r = decoct($x);
    1355. 

  1355. 		if (strlen($r) == 11) {
    1356. 

  1356. 			//	Two's Complement
    1357. 

  1357. 			$r = substr($r,-10);
    1358. 

  1358. 		}
    1359. 

  1359. 

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

  1361. 	}	//	function DECTOOCT()
    1362. 

  1362. 

  1363. 

  1364. 	/**
    1365. 

  1365. 	 * HEXTOBIN
    1366. 

  1366. 	 *
    1367. 

  1367. 	 * Return a hex value as binary.
    1368. 

  1368. 	 *
    1369. 

  1369. 	 * Excel Function:
    1370. 

  1370. 	 *		HEX2BIN(x[,places])
    1371. 

  1371. 	 *
    1372. 

  1372. 	 * @access	public
    1373. 

  1373. 	 * @category Engineering Functions
    1374. 

  1374. 	 * @param	string		$x			the hexadecimal number you want to convert. Number cannot
    1375. 

  1375. 	 *									contain more than 10 characters. The most significant bit of
    1376. 

  1376. 	 *									number is the sign bit (40th bit from the right). The remaining
    1377. 

  1377. 	 *									9 bits are magnitude bits. Negative numbers are represented
    1378. 

  1378. 	 *									using two's-complement notation.
    1379. 

  1379. 	 *									If number is negative, HEX2BIN ignores places and returns a
    1380. 

  1380. 	 *									10-character binary number.
    1381. 

  1381. 	 *									If number is negative, it cannot be less than FFFFFFFE00, and
    1382. 

  1382. 	 *									if number is positive, it cannot be greater than 1FF.
    1383. 

  1383. 	 *									If number is not a valid hexadecimal number, HEX2BIN returns
    1384. 

  1384. 	 *									the #NUM! error value.
    1385. 

  1385. 	 *									If HEX2BIN requires more than places characters, it returns
    1386. 

  1386. 	 *									the #NUM! error value.
    1387. 

  1387. 	 * @param	integer		$places		The number of characters to use. If places is omitted,
    1388. 

  1388. 	 *									HEX2BIN uses the minimum number of characters necessary. Places
    1389. 

  1389. 	 *									is useful for padding the return value with leading 0s (zeros).
    1390. 

  1390. 	 *									If places is not an integer, it is truncated.
    1391. 

  1391. 	 *									If places is nonnumeric, HEX2BIN returns the #VALUE! error value.
    1392. 

  1392. 	 *									If places is negative, HEX2BIN returns the #NUM! error value.
    1393. 

  1393. 	 * @return	string
    1394. 

  1394. 	 */
    1395. 

  1395. 	public static function HEXTOBIN($x, $places=null) {
    1396. 

  1396. 		$x	= PHPExcel_Calculation_Functions::flattenSingleValue($x);
    1397. 

  1397. 		$places	= PHPExcel_Calculation_Functions::flattenSingleValue($places);
    1398. 

  1398. 

  1399. 		if (is_bool($x)) {
    1400. 

  1400. 			return PHPExcel_Calculation_Functions::VALUE();
    1401. 

  1401. 		}
    1402. 

  1402. 		$x = (string) $x;
    1403. 

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

  1404. 			return PHPExcel_Calculation_Functions::NaN();
    1405. 

  1405. 		}
    1406. 

  1406. 		$binVal = decbin(hexdec($x));
    1407. 

  1407. 

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

  1409. 	}	//	function HEXTOBIN()
    1410. 

  1410. 

  1411. 

  1412. 	/**
    1413. 

  1413. 	 * HEXTODEC
    1414. 

  1414. 	 *
    1415. 

  1415. 	 * Return a hex value as decimal.
    1416. 

  1416. 	 *
    1417. 

  1417. 	 * Excel Function:
    1418. 

  1418. 	 *		HEX2DEC(x)
    1419. 

  1419. 	 *
    1420. 

  1420. 	 * @access	public
    1421. 

  1421. 	 * @category Engineering Functions
    1422. 

  1422. 	 * @param	string		$x		The hexadecimal number you want to convert. This number cannot
    1423. 

  1423. 	 *								contain more than 10 characters (40 bits). The most significant
    1424. 

  1424. 	 *								bit of number is the sign bit. The remaining 39 bits are magnitude
    1425. 

  1425. 	 *								bits. Negative numbers are represented using two's-complement
    1426. 

  1426. 	 *								notation.
    1427. 

  1427. 	 *								If number is not a valid hexadecimal number, HEX2DEC returns the
    1428. 

  1428. 	 *								#NUM! error value.
    1429. 

  1429. 	 * @return	string
    1430. 

  1430. 	 */
    1431. 

  1431. 	public static function HEXTODEC($x) {
    1432. 

  1432. 		$x	= PHPExcel_Calculation_Functions::flattenSingleValue($x);
    1433. 

  1433. 

  1434. 		if (is_bool($x)) {
    1435. 

  1435. 			return PHPExcel_Calculation_Functions::VALUE();
    1436. 

  1436. 		}
    1437. 

  1437. 		$x = (string) $x;
    1438. 

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

  1439. 			return PHPExcel_Calculation_Functions::NaN();
    1440. 

  1440. 		}
    1441. 

  1441. 		return hexdec($x);
    1442. 

  1442. 	}	//	function HEXTODEC()
    1443. 

  1443. 

  1444. 

  1445. 	/**
    1446. 

  1446. 	 * HEXTOOCT
    1447. 

  1447. 	 *
    1448. 

  1448. 	 * Return a hex value as octal.
    1449. 

  1449. 	 *
    1450. 

  1450. 	 * Excel Function:
    1451. 

  1451. 	 *		HEX2OCT(x[,places])
    1452. 

  1452. 	 *
    1453. 

  1453. 	 * @access	public
    1454. 

  1454. 	 * @category Engineering Functions
    1455. 

  1455. 	 * @param	string		$x			The hexadecimal number you want to convert. Number cannot
    1456. 

  1456. 	 *									contain more than 10 characters. The most significant bit of
    1457. 

  1457. 	 *									number is the sign bit. The remaining 39 bits are magnitude
    1458. 

  1458. 	 *									bits. Negative numbers are represented using two's-complement
    1459. 

  1459. 	 *									notation.
    1460. 

  1460. 	 *									If number is negative, HEX2OCT ignores places and returns a
    1461. 

  1461. 	 *									10-character octal number.
    1462. 

  1462. 	 *									If number is negative, it cannot be less than FFE0000000, and
    1463. 

  1463. 	 *									if number is positive, it cannot be greater than 1FFFFFFF.
    1464. 

  1464. 	 *									If number is not a valid hexadecimal number, HEX2OCT returns
    1465. 

  1465. 	 *									the #NUM! error value.
    1466. 

  1466. 	 *									If HEX2OCT requires more than places characters, it returns
    1467. 

  1467. 	 *									the #NUM! error value.
    1468. 

  1468. 	 * @param	integer		$places		The number of characters to use. If places is omitted, HEX2OCT
    1469. 

  1469. 	 *									uses the minimum number of characters necessary. Places is
    1470. 

  1470. 	 *									useful for padding the return value with leading 0s (zeros).
    1471. 

  1471. 	 *									If places is not an integer, it is truncated.
    1472. 

  1472. 	 *									If places is nonnumeric, HEX2OCT returns the #VALUE! error
    1473. 

  1473. 	 *									value.
    1474. 

  1474. 	 *									If places is negative, HEX2OCT returns the #NUM! error value.
    1475. 

  1475. 	 * @return	string
    1476. 

  1476. 	 */
    1477. 

  1477. 	public static function HEXTOOCT($x, $places=null) {
    1478. 

  1478. 		$x	= PHPExcel_Calculation_Functions::flattenSingleValue($x);
    1479. 

  1479. 		$places	= PHPExcel_Calculation_Functions::flattenSingleValue($places);
    1480. 

  1480. 

  1481. 		if (is_bool($x)) {
    1482. 

  1482. 			return PHPExcel_Calculation_Functions::VALUE();
    1483. 

  1483. 		}
    1484. 

  1484. 		$x = (string) $x;
    1485. 

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

  1486. 			return PHPExcel_Calculation_Functions::NaN();
    1487. 

  1487. 		}
    1488. 

  1488. 		$octVal = decoct(hexdec($x));
    1489. 

  1489. 

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

  1491. 	}	//	function HEXTOOCT()
    1492. 

  1492. 

  1493. 

  1494. 	/**
    1495. 

  1495. 	 * OCTTOBIN
    1496. 

  1496. 	 *
    1497. 

  1497. 	 * Return an octal value as binary.
    1498. 

  1498. 	 *
    1499. 

  1499. 	 * Excel Function:
    1500. 

  1500. 	 *		OCT2BIN(x[,places])
    1501. 

  1501. 	 *
    1502. 

  1502. 	 * @access	public
    1503. 

  1503. 	 * @category Engineering Functions
    1504. 

  1504. 	 * @param	string		$x			The octal number you want to convert. Number may not
    1505. 

  1505. 	 *									contain more than 10 characters. The most significant
    1506. 

  1506. 	 *									bit of number is the sign bit. The remaining 29 bits
    1507. 

  1507. 	 *									are magnitude bits. Negative numbers are represented
    1508. 

  1508. 	 *									using two's-complement notation.
    1509. 

  1509. 	 *									If number is negative, OCT2BIN ignores places and returns
    1510. 

  1510. 	 *									a 10-character binary number.
    1511. 

  1511. 	 *									If number is negative, it cannot be less than 7777777000,
    1512. 

  1512. 	 *									and if number is positive, it cannot be greater than 777.
    1513. 

  1513. 	 *									If number is not a valid octal number, OCT2BIN returns
    1514. 

  1514. 	 *									the #NUM! error value.
    1515. 

  1515. 	 *									If OCT2BIN requires more than places characters, it
    1516. 

  1516. 	 *									returns the #NUM! error value.
    1517. 

  1517. 	 * @param	integer		$places		The number of characters to use. If places is omitted,
    1518. 

  1518. 	 *									OCT2BIN uses the minimum number of characters necessary.
    1519. 

  1519. 	 *									Places is useful for padding the return value with
    1520. 

  1520. 	 *									leading 0s (zeros).
    1521. 

  1521. 	 *									If places is not an integer, it is truncated.
    1522. 

  1522. 	 *									If places is nonnumeric, OCT2BIN returns the #VALUE!
    1523. 

  1523. 	 *									error value.
    1524. 

  1524. 	 *									If places is negative, OCT2BIN returns the #NUM! error
    1525. 

  1525. 	 *									value.
    1526. 

  1526. 	 * @return	string
    1527. 

  1527. 	 */
    1528. 

  1528. 	public static function OCTTOBIN($x, $places=null) {
    1529. 

  1529. 		$x	= PHPExcel_Calculation_Functions::flattenSingleValue($x);
    1530. 

  1530. 		$places	= PHPExcel_Calculation_Functions::flattenSingleValue($places);
    1531. 

  1531. 

  1532. 		if (is_bool($x)) {
    1533. 

  1533. 			return PHPExcel_Calculation_Functions::VALUE();
    1534. 

  1534. 		}
    1535. 

  1535. 		$x = (string) $x;
    1536. 

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

  1537. 			return PHPExcel_Calculation_Functions::NaN();
    1538. 

  1538. 		}
    1539. 

  1539. 		$r = decbin(octdec($x));
    1540. 

  1540. 

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

  1542. 	}	//	function OCTTOBIN()
    1543. 

  1543. 

  1544. 

  1545. 	/**
    1546. 

  1546. 	 * OCTTODEC
    1547. 

  1547. 	 *
    1548. 

  1548. 	 * Return an octal value as decimal.
    1549. 

  1549. 	 *
    1550. 

  1550. 	 * Excel Function:
    1551. 

  1551. 	 *		OCT2DEC(x)
    1552. 

  1552. 	 *
    1553. 

  1553. 	 * @access	public
    1554. 

  1554. 	 * @category Engineering Functions
    1555. 

  1555. 	 * @param	string		$x		The octal number you want to convert. Number may not contain
    1556. 

  1556. 	 *								more than 10 octal characters (30 bits). The most significant
    1557. 

  1557. 	 *								bit of number is the sign bit. The remaining 29 bits are
    1558. 

  1558. 	 *								magnitude bits. Negative numbers are represented using
    1559. 

  1559. 	 *								two's-complement notation.
    1560. 

  1560. 	 *								If number is not a valid octal number, OCT2DEC returns the
    1561. 

  1561. 	 *								#NUM! error value.
    1562. 

  1562. 	 * @return	string
    1563. 

  1563. 	 */
    1564. 

  1564. 	public static function OCTTODEC($x) {
    1565. 

  1565. 		$x	= PHPExcel_Calculation_Functions::flattenSingleValue($x);
    1566. 

  1566. 

  1567. 		if (is_bool($x)) {
    1568. 

  1568. 			return PHPExcel_Calculation_Functions::VALUE();
    1569. 

  1569. 		}
    1570. 

  1570. 		$x = (string) $x;
    1571. 

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

  1572. 			return PHPExcel_Calculation_Functions::NaN();
    1573. 

  1573. 		}
    1574. 

  1574. 		return octdec($x);
    1575. 

  1575. 	}	//	function OCTTODEC()
    1576. 

  1576. 

  1577. 

  1578. 	/**
    1579. 

  1579. 	 * OCTTOHEX
    1580. 

  1580. 	 *
    1581. 

  1581. 	 * Return an octal value as hex.
    1582. 

  1582. 	 *
    1583. 

  1583. 	 * Excel Function:
    1584. 

  1584. 	 *		OCT2HEX(x[,places])
    1585. 

  1585. 	 *
    1586. 

  1586. 	 * @access	public
    1587. 

  1587. 	 * @category Engineering Functions
    1588. 

  1588. 	 * @param	string		$x			The octal number you want to convert. Number may not contain
    1589. 

  1589. 	 *									more than 10 octal characters (30 bits). The most significant
    1590. 

  1590. 	 *									bit of number is the sign bit. The remaining 29 bits are
    1591. 

  1591. 	 *									magnitude bits. Negative numbers are represented using
    1592. 

  1592. 	 *									two's-complement notation.
    1593. 

  1593. 	 *									If number is negative, OCT2HEX ignores places and returns a
    1594. 

  1594. 	 *									10-character hexadecimal number.
    1595. 

  1595. 	 *									If number is not a valid octal number, OCT2HEX returns the
    1596. 

  1596. 	 *									#NUM! error value.
    1597. 

  1597. 	 *									If OCT2HEX requires more than places characters, it returns
    1598. 

  1598. 	 *									the #NUM! error value.
    1599. 

  1599. 	 * @param	integer		$places		The number of characters to use. If places is omitted, OCT2HEX
    1600. 

  1600. 	 *									uses the minimum number of characters necessary. Places is useful
    1601. 

  1601. 	 *									for padding the return value with leading 0s (zeros).
    1602. 

  1602. 	 *									If places is not an integer, it is truncated.
    1603. 

  1603. 	 *									If places is nonnumeric, OCT2HEX returns the #VALUE! error value.
    1604. 

  1604. 	 *									If places is negative, OCT2HEX returns the #NUM! error value.
    1605. 

  1605. 	 * @return	string
    1606. 

  1606. 	 */
    1607. 

  1607. 	public static function OCTTOHEX($x, $places=null) {
    1608. 

  1608. 		$x	= PHPExcel_Calculation_Functions::flattenSingleValue($x);
    1609. 

  1609. 		$places	= PHPExcel_Calculation_Functions::flattenSingleValue($places);
    1610. 

  1610. 

  1611. 		if (is_bool($x)) {
    1612. 

  1612. 			return PHPExcel_Calculation_Functions::VALUE();
    1613. 

  1613. 		}
    1614. 

  1614. 		$x = (string) $x;
    1615. 

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

  1616. 			return PHPExcel_Calculation_Functions::NaN();
    1617. 

  1617. 		}
    1618. 

  1618. 		$hexVal = strtoupper(dechex(octdec($x)));
    1619. 

  1619. 

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

  1621. 	}	//	function OCTTOHEX()
    1622. 

  1622. 

  1623. 

  1624. 	/**
    1625. 

  1625. 	 * COMPLEX
    1626. 

  1626. 	 *
    1627. 

  1627. 	 * Converts real and imaginary coefficients into a complex number of the form x + yi or x + yj.
    1628. 

  1628. 	 *
    1629. 

  1629. 	 * Excel Function:
    1630. 

  1630. 	 *		COMPLEX(realNumber,imaginary[,places])
    1631. 

  1631. 	 *
    1632. 

  1632. 	 * @access	public
    1633. 

  1633. 	 * @category Engineering Functions
    1634. 

  1634. 	 * @param	float		$realNumber		The real coefficient of the complex number.
    1635. 

  1635. 	 * @param	float		$imaginary		The imaginary coefficient of the complex number.
    1636. 

  1636. 	 * @param	string		$suffix			The suffix for the imaginary component of the complex number.
    1637. 

  1637. 	 *										If omitted, the suffix is assumed to be "i".
    1638. 

  1638. 	 * @return	string
    1639. 

  1639. 	 */
    1640. 

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

  1641. 		$realNumber	= (is_null($realNumber))	? 0.0 :	PHPExcel_Calculation_Functions::flattenSingleValue($realNumber);
    1642. 

  1642. 		$imaginary	= (is_null($imaginary))		? 0.0 :	PHPExcel_Calculation_Functions::flattenSingleValue($imaginary);
    1643. 

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

  1644. 

  1645. 		if (((is_numeric($realNumber)) && (is_numeric($imaginary))) &&
    1646. 

  1646. 			(($suffix == 'i') || ($suffix == 'j') || ($suffix == ''))) {
    1647. 

  1647. 			$realNumber	= (float) $realNumber;
    1648. 

  1648. 			$imaginary	= (float) $imaginary;
    1649. 

  1649. 

  1650. 			if ($suffix == '') $suffix = 'i';
    1651. 

  1651. 			if ($realNumber == 0.0) {
    1652. 

  1652. 				if ($imaginary == 0.0) {
    1653. 

  1653. 					return (string) '0';
    1654. 

  1654. 				} elseif ($imaginary == 1.0) {
    1655. 

  1655. 					return (string) $suffix;
    1656. 

  1656. 				} elseif ($imaginary == -1.0) {
    1657. 

  1657. 					return (string) '-'.$suffix;
    1658. 

  1658. 				}
    1659. 

  1659. 				return (string) $imaginary.$suffix;
    1660. 

  1660. 			} elseif ($imaginary == 0.0) {
    1661. 

  1661. 				return (string) $realNumber;
    1662. 

  1662. 			} elseif ($imaginary == 1.0) {
    1663. 

  1663. 				return (string) $realNumber.'+'.$suffix;
    1664. 

  1664. 			} elseif ($imaginary == -1.0) {
    1665. 

  1665. 				return (string) $realNumber.'-'.$suffix;
    1666. 

  1666. 			}
    1667. 

  1667. 			if ($imaginary > 0) { $imaginary = (string) '+'.$imaginary; }
    1668. 

  1668. 			return (string) $realNumber.$imaginary.$suffix;
    1669. 

  1669. 		}
    1670. 

  1670. 

  1671. 		return PHPExcel_Calculation_Functions::VALUE();
    1672. 

  1672. 	}	//	function COMPLEX()
    1673. 

  1673. 

  1674. 

  1675. 	/**
    1676. 

  1676. 	 * IMAGINARY
    1677. 

  1677. 	 *
    1678. 

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

  1679. 	 *
    1680. 

  1680. 	 * Excel Function:
    1681. 

  1681. 	 *		IMAGINARY(complexNumber)
    1682. 

  1682. 	 *
    1683. 

  1683. 	 * @access	public
    1684. 

  1684. 	 * @category Engineering Functions
    1685. 

  1685. 	 * @param	string		$complexNumber	The complex number for which you want the imaginary
    1686. 

  1686. 	 * 										coefficient.
    1687. 

  1687. 	 * @return	float
    1688. 

  1688. 	 */
    1689. 

  1689. 	public static function IMAGINARY($complexNumber) {
    1690. 

  1690. 		$complexNumber	= PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
    1691. 

  1691. 

  1692. 		$parsedComplex = self::_parseComplex($complexNumber);
    1693. 

  1693. 		return $parsedComplex['imaginary'];
    1694. 

  1694. 	}	//	function IMAGINARY()
    1695. 

  1695. 

  1696. 

  1697. 	/**
    1698. 

  1698. 	 * IMREAL
    1699. 

  1699. 	 *
    1700. 

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

  1701. 	 *
    1702. 

  1702. 	 * Excel Function:
    1703. 

  1703. 	 *		IMREAL(complexNumber)
    1704. 

  1704. 	 *
    1705. 

  1705. 	 * @access	public
    1706. 

  1706. 	 * @category Engineering Functions
    1707. 

  1707. 	 * @param	string		$complexNumber	The complex number for which you want the real coefficient.
    1708. 

  1708. 	 * @return	float
    1709. 

  1709. 	 */
    1710. 

  1710. 	public static function IMREAL($complexNumber) {
    1711. 

  1711. 		$complexNumber	= PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
    1712. 

  1712. 

  1713. 		$parsedComplex = self::_parseComplex($complexNumber);
    1714. 

  1714. 		return $parsedComplex['real'];
    1715. 

  1715. 	}	//	function IMREAL()
    1716. 

  1716. 

  1717. 

  1718. 	/**
    1719. 

  1719. 	 * IMABS
    1720. 

  1720. 	 *
    1721. 

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

  1722. 	 *
    1723. 

  1723. 	 * Excel Function:
    1724. 

  1724. 	 *		IMABS(complexNumber)
    1725. 

  1725. 	 *
    1726. 

  1726. 	 * @param	string		$complexNumber	The complex number for which you want the absolute value.
    1727. 

  1727. 	 * @return	float
    1728. 

  1728. 	 */
    1729. 

  1729. 	public static function IMABS($complexNumber) {
    1730. 

  1730. 		$complexNumber	= PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
    1731. 

  1731. 

  1732. 		$parsedComplex = self::_parseComplex($complexNumber);
    1733. 

  1733. 

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

  1735. 	}	//	function IMABS()
    1736. 

  1736. 

  1737. 

  1738. 	/**
    1739. 

  1739. 	 * IMARGUMENT
    1740. 

  1740. 	 *
    1741. 

  1741. 	 * Returns the argument theta of a complex number, i.e. the angle in radians from the real
    1742. 

  1742. 	 * axis to the representation of the number in polar coordinates.
    1743. 

  1743. 	 *
    1744. 

  1744. 	 * Excel Function:
    1745. 

  1745. 	 *		IMARGUMENT(complexNumber)
    1746. 

  1746. 	 *
    1747. 

  1747. 	 * @param	string		$complexNumber	The complex number for which you want the argument theta.
    1748. 

  1748. 	 * @return	float
    1749. 

  1749. 	 */
    1750. 

  1750. 	public static function IMARGUMENT($complexNumber) {
    1751. 

  1751. 		$complexNumber	= PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
    1752. 

  1752. 

  1753. 		$parsedComplex = self::_parseComplex($complexNumber);
    1754. 

  1754. 

  1755. 		if ($parsedComplex['real'] == 0.0) {
    1756. 

  1756. 			if ($parsedComplex['imaginary'] == 0.0) {
    1757. 

  1757. 				return 0.0;
    1758. 

  1758. 			} elseif($parsedComplex['imaginary'] < 0.0) {
    1759. 

  1759. 				return M_PI / -2;
    1760. 

  1760. 			} else {
    1761. 

  1761. 				return M_PI / 2;
    1762. 

  1762. 			}
    1763. 

  1763. 		} elseif ($parsedComplex['real'] > 0.0) {
    1764. 

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

  1765. 		} elseif ($parsedComplex['imaginary'] < 0.0) {
    1766. 

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

  1767. 		} else {
    1768. 

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

  1769. 		}
    1770. 

  1770. 	}	//	function IMARGUMENT()
    1771. 

  1771. 

  1772. 

  1773. 	/**
    1774. 

  1774. 	 * IMCONJUGATE
    1775. 

  1775. 	 *
    1776. 

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

  1777. 	 *
    1778. 

  1778. 	 * Excel Function:
    1779. 

  1779. 	 *		IMCONJUGATE(complexNumber)
    1780. 

  1780. 	 *
    1781. 

  1781. 	 * @param	string		$complexNumber	The complex number for which you want the conjugate.
    1782. 

  1782. 	 * @return	string
    1783. 

  1783. 	 */
    1784. 

  1784. 	public static function IMCONJUGATE($complexNumber) {
    1785. 

  1785. 		$complexNumber	= PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
    1786. 

  1786. 

  1787. 		$parsedComplex = self::_parseComplex($complexNumber);
    1788. 

  1788. 

  1789. 		if ($parsedComplex['imaginary'] == 0.0) {
    1790. 

  1790. 			return $parsedComplex['real'];
    1791. 

  1791. 		} else {
    1792. 

  1792. 			return self::_cleanComplex( self::COMPLEX( $parsedComplex['real'],
    1793. 

  1793. 													   0 - $parsedComplex['imaginary'],
    1794. 

  1794. 													   $parsedComplex['suffix']
    1795. 

  1795. 													 )
    1796. 

  1796. 									  );
    1797. 

  1797. 		}
    1798. 

  1798. 	}	//	function IMCONJUGATE()
    1799. 

  1799. 

  1800. 

  1801. 	/**
    1802. 

  1802. 	 * IMCOS
    1803. 

  1803. 	 *
    1804. 

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

  1805. 	 *
    1806. 

  1806. 	 * Excel Function:
    1807. 

  1807. 	 *		IMCOS(complexNumber)
    1808. 

  1808. 	 *
    1809. 

  1809. 	 * @param	string		$complexNumber	The complex number for which you want the cosine.
    1810. 

  1810. 	 * @return	string|float
    1811. 

  1811. 	 */
    1812. 

  1812. 	public static function IMCOS($complexNumber) {
    1813. 

  1813. 		$complexNumber	= PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
    1814. 

  1814. 

  1815. 		$parsedComplex = self::_parseComplex($complexNumber);
    1816. 

  1816. 

  1817. 		if ($parsedComplex['imaginary'] == 0.0) {
    1818. 

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

  1819. 		} else {
    1820. 

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

  1821. 		}
    1822. 

  1822. 	}	//	function IMCOS()
    1823. 

  1823. 

  1824. 

  1825. 	/**
    1826. 

  1826. 	 * IMSIN
    1827. 

  1827. 	 *
    1828. 

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

  1829. 	 *
    1830. 

  1830. 	 * Excel Function:
    1831. 

  1831. 	 *		IMSIN(complexNumber)
    1832. 

  1832. 	 *
    1833. 

  1833. 	 * @param	string		$complexNumber	The complex number for which you want the sine.
    1834. 

  1834. 	 * @return	string|float
    1835. 

  1835. 	 */
    1836. 

  1836. 	public static function IMSIN($complexNumber) {
    1837. 

  1837. 		$complexNumber	= PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
    1838. 

  1838. 

  1839. 		$parsedComplex = self::_parseComplex($complexNumber);
    1840. 

  1840. 

  1841. 		if ($parsedComplex['imaginary'] == 0.0) {
    1842. 

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

  1843. 		} else {
    1844. 

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

  1845. 		}
    1846. 

  1846. 	}	//	function IMSIN()
    1847. 

  1847. 

  1848. 

  1849. 	/**
    1850. 

  1850. 	 * IMSQRT
    1851. 

  1851. 	 *
    1852. 

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

  1853. 	 *
    1854. 

  1854. 	 * Excel Function:
    1855. 

  1855. 	 *		IMSQRT(complexNumber)
    1856. 

  1856. 	 *
    1857. 

  1857. 	 * @param	string		$complexNumber	The complex number for which you want the square root.
    1858. 

  1858. 	 * @return	string
    1859. 

  1859. 	 */
    1860. 

  1860. 	public static function IMSQRT($complexNumber) {
    1861. 

  1861. 		$complexNumber	= PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
    1862. 

  1862. 

  1863. 		$parsedComplex = self::_parseComplex($complexNumber);
    1864. 

  1864. 

  1865. 		$theta = self::IMARGUMENT($complexNumber);
    1866. 

  1866. 		$d1 = cos($theta / 2);
    1867. 

  1867. 		$d2 = sin($theta / 2);
    1868. 

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

  1869. 

  1870. 		if ($parsedComplex['suffix'] == '') {
    1871. 

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

  1872. 		} else {
    1873. 

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

  1874. 		}
    1875. 

  1875. 	}	//	function IMSQRT()
    1876. 

  1876. 

  1877. 

  1878. 	/**
    1879. 

  1879. 	 * IMLN
    1880. 

  1880. 	 *
    1881. 

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

  1882. 	 *
    1883. 

  1883. 	 * Excel Function:
    1884. 

  1884. 	 *		IMLN(complexNumber)
    1885. 

  1885. 	 *
    1886. 

  1886. 	 * @param	string		$complexNumber	The complex number for which you want the natural logarithm.
    1887. 

  1887. 	 * @return	string
    1888. 

  1888. 	 */
    1889. 

  1889. 	public static function IMLN($complexNumber) {
    1890. 

  1890. 		$complexNumber	= PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
    1891. 

  1891. 

  1892. 		$parsedComplex = self::_parseComplex($complexNumber);
    1893. 

  1893. 

  1894. 		if (($parsedComplex['real'] == 0.0) && ($parsedComplex['imaginary'] == 0.0)) {
    1895. 

  1895. 			return PHPExcel_Calculation_Functions::NaN();
    1896. 

  1896. 		}
    1897. 

  1897. 

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

  1899. 		$t = self::IMARGUMENT($complexNumber);
    1900. 

  1900. 

  1901. 		if ($parsedComplex['suffix'] == '') {
    1902. 

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

  1903. 		} else {
    1904. 

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

  1905. 		}
    1906. 

  1906. 	}	//	function IMLN()
    1907. 

  1907. 

  1908. 

  1909. 	/**
    1910. 

  1910. 	 * IMLOG10
    1911. 

  1911. 	 *
    1912. 

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

  1913. 	 *
    1914. 

  1914. 	 * Excel Function:
    1915. 

  1915. 	 *		IMLOG10(complexNumber)
    1916. 

  1916. 	 *
    1917. 

  1917. 	 * @param	string		$complexNumber	The complex number for which you want the common logarithm.
    1918. 

  1918. 	 * @return	string
    1919. 

  1919. 	 */
    1920. 

  1920. 	public static function IMLOG10($complexNumber) {
    1921. 

  1921. 		$complexNumber	= PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
    1922. 

  1922. 

  1923. 		$parsedComplex = self::_parseComplex($complexNumber);
    1924. 

  1924. 

  1925. 		if (($parsedComplex['real'] == 0.0) && ($parsedComplex['imaginary'] == 0.0)) {
    1926. 

  1926. 			return PHPExcel_Calculation_Functions::NaN();
    1927. 

  1927. 		} elseif (($parsedComplex['real'] > 0.0) && ($parsedComplex['imaginary'] == 0.0)) {
    1928. 

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

  1929. 		}
    1930. 

  1930. 

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

  1932. 	}	//	function IMLOG10()
    1933. 

  1933. 

  1934. 

  1935. 	/**
    1936. 

  1936. 	 * IMLOG2
    1937. 

  1937. 	 *
    1938. 

  1938. 	 * Returns the base-2 logarithm of a complex number in x + yi or x + yj text format.
    1939. 

  1939. 	 *
    1940. 

  1940. 	 * Excel Function:
    1941. 

  1941. 	 *		IMLOG2(complexNumber)
    1942. 

  1942. 	 *
    1943. 

  1943. 	 * @param	string		$complexNumber	The complex number for which you want the base-2 logarithm.
    1944. 

  1944. 	 * @return	string
    1945. 

  1945. 	 */
    1946. 

  1946. 	public static function IMLOG2($complexNumber) {
    1947. 

  1947. 		$complexNumber	= PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
    1948. 

  1948. 

  1949. 		$parsedComplex = self::_parseComplex($complexNumber);
    1950. 

  1950. 

  1951. 		if (($parsedComplex['real'] == 0.0) && ($parsedComplex['imaginary'] == 0.0)) {
    1952. 

  1952. 			return PHPExcel_Calculation_Functions::NaN();
    1953. 

  1953. 		} elseif (($parsedComplex['real'] > 0.0) && ($parsedComplex['imaginary'] == 0.0)) {
    1954. 

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

  1955. 		}
    1956. 

  1956. 

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

  1958. 	}	//	function IMLOG2()
    1959. 

  1959. 

  1960. 

  1961. 	/**
    1962. 

  1962. 	 * IMEXP
    1963. 

  1963. 	 *
    1964. 

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

  1965. 	 *
    1966. 

  1966. 	 * Excel Function:
    1967. 

  1967. 	 *		IMEXP(complexNumber)
    1968. 

  1968. 	 *
    1969. 

  1969. 	 * @param	string		$complexNumber	The complex number for which you want the exponential.
    1970. 

  1970. 	 * @return	string
    1971. 

  1971. 	 */
    1972. 

  1972. 	public static function IMEXP($complexNumber) {
    1973. 

  1973. 		$complexNumber	= PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
    1974. 

  1974. 

  1975. 		$parsedComplex = self::_parseComplex($complexNumber);
    1976. 

  1976. 

  1977. 		if (($parsedComplex['real'] == 0.0) && ($parsedComplex['imaginary'] == 0.0)) {
    1978. 

  1978. 			return '1';
    1979. 

  1979. 		}
    1980. 

  1980. 

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

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

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

  1984. 

  1985. 		if ($parsedComplex['suffix'] == '') {
    1986. 

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

  1987. 		} else {
    1988. 

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

  1989. 		}
    1990. 

  1990. 	}	//	function IMEXP()
    1991. 

  1991. 

  1992. 

  1993. 	/**
    1994. 

  1994. 	 * IMPOWER
    1995. 

  1995. 	 *
    1996. 

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

  1997. 	 *
    1998. 

  1998. 	 * Excel Function:
    1999. 

  1999. 	 *		IMPOWER(complexNumber,realNumber)
    2000. 

  2000. 	 *
    2001. 

  2001. 	 * @param	string		$complexNumber	The complex number you want to raise to a power.
    2002. 

  2002. 	 * @param	float		$realNumber		The power to which you want to raise the complex number.
    2003. 

  2003. 	 * @return	string
    2004. 

  2004. 	 */
    2005. 

  2005. 	public static function IMPOWER($complexNumber,$realNumber) {
    2006. 

  2006. 		$complexNumber	= PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
    2007. 

  2007. 		$realNumber		= PHPExcel_Calculation_Functions::flattenSingleValue($realNumber);
    2008. 

  2008. 

  2009. 		if (!is_numeric($realNumber)) {
    2010. 

  2010. 			return PHPExcel_Calculation_Functions::VALUE();
    2011. 

  2011. 		}
    2012. 

  2012. 

  2013. 		$parsedComplex = self::_parseComplex($complexNumber);
    2014. 

  2014. 

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

  2016. 		$rPower = pow($r,$realNumber);
    2017. 

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

  2018. 		if ($theta == 0) {
    2019. 

  2019. 			return 1;
    2020. 

  2020. 		} elseif ($parsedComplex['imaginary'] == 0.0) {
    2021. 

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

  2022. 		} else {
    2023. 

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

  2024. 		}
    2025. 

  2025. 	}	//	function IMPOWER()
    2026. 

  2026. 

  2027. 

  2028. 	/**
    2029. 

  2029. 	 * IMDIV
    2030. 

  2030. 	 *
    2031. 

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

  2032. 	 *
    2033. 

  2033. 	 * Excel Function:
    2034. 

  2034. 	 *		IMDIV(complexDividend,complexDivisor)
    2035. 

  2035. 	 *
    2036. 

  2036. 	 * @param	string		$complexDividend	The complex numerator or dividend.
    2037. 

  2037. 	 * @param	string		$complexDivisor		The complex denominator or divisor.
    2038. 

  2038. 	 * @return	string
    2039. 

  2039. 	 */
    2040. 

  2040. 	public static function IMDIV($complexDividend,$complexDivisor) {
    2041. 

  2041. 		$complexDividend	= PHPExcel_Calculation_Functions::flattenSingleValue($complexDividend);
    2042. 

  2042. 		$complexDivisor	= PHPExcel_Calculation_Functions::flattenSingleValue($complexDivisor);
    2043. 

  2043. 

  2044. 		$parsedComplexDividend = self::_parseComplex($complexDividend);
    2045. 

  2045. 		$parsedComplexDivisor = self::_parseComplex($complexDivisor);
    2046. 

  2046. 

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

  2048. 			($parsedComplexDividend['suffix'] != $parsedComplexDivisor['suffix'])) {
    2049. 

  2049. 			return PHPExcel_Calculation_Functions::NaN();
    2050. 

  2050. 		}
    2051. 

  2051. 		if (($parsedComplexDividend['suffix'] != '') && ($parsedComplexDivisor['suffix'] == '')) {
    2052. 

  2052. 			$parsedComplexDivisor['suffix'] = $parsedComplexDividend['suffix'];
    2053. 

  2053. 		}
    2054. 

  2054. 

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

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

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

  2058. 

  2059. 		$r = $d1/$d3;
    2060. 

  2060. 		$i = $d2/$d3;
    2061. 

  2061. 

  2062. 		if ($i > 0.0) {
    2063. 

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

  2064. 		} elseif ($i < 0.0) {
    2065. 

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

  2066. 		} else {
    2067. 

  2067. 			return $r;
    2068. 

  2068. 		}
    2069. 

  2069. 	}	//	function IMDIV()
    2070. 

  2070. 

  2071. 

  2072. 	/**
    2073. 

  2073. 	 * IMSUB
    2074. 

  2074. 	 *
    2075. 

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

  2076. 	 *
    2077. 

  2077. 	 * Excel Function:
    2078. 

  2078. 	 *		IMSUB(complexNumber1,complexNumber2)
    2079. 

  2079. 	 *
    2080. 

  2080. 	 * @param	string		$complexNumber1		The complex number from which to subtract complexNumber2.
    2081. 

  2081. 	 * @param	string		$complexNumber2		The complex number to subtract from complexNumber1.
    2082. 

  2082. 	 * @return	string
    2083. 

  2083. 	 */
    2084. 

  2084. 	public static function IMSUB($complexNumber1,$complexNumber2) {
    2085. 

  2085. 		$complexNumber1	= PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber1);
    2086. 

  2086. 		$complexNumber2	= PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber2);
    2087. 

  2087. 

  2088. 		$parsedComplex1 = self::_parseComplex($complexNumber1);
    2089. 

  2089. 		$parsedComplex2 = self::_parseComplex($complexNumber2);
    2090. 

  2090. 

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

  2092. 			($parsedComplex1['suffix'] != $parsedComplex2['suffix'])) {
    2093. 

  2093. 			return PHPExcel_Calculation_Functions::NaN();
    2094. 

  2094. 		} elseif (($parsedComplex1['suffix'] == '') && ($parsedComplex2['suffix'] != '')) {
    2095. 

  2095. 			$parsedComplex1['suffix'] = $parsedComplex2['suffix'];
    2096. 

  2096. 		}
    2097. 

  2097. 

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

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

  2100. 

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

  2102. 	}	//	function IMSUB()
    2103. 

  2103. 

  2104. 

  2105. 	/**
    2106. 

  2106. 	 * IMSUM
    2107. 

  2107. 	 *
    2108. 

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

  2109. 	 *
    2110. 

  2110. 	 * Excel Function:
    2111. 

  2111. 	 *		IMSUM(complexNumber[,complexNumber[,...]])
    2112. 

  2112. 	 *
    2113. 

  2113. 	 * @param	string		$complexNumber,...	Series of complex numbers to add
    2114. 

  2114. 	 * @return	string
    2115. 

  2115. 	 */
    2116. 

  2116. 	public static function IMSUM() {
    2117. 

  2117. 		// Return value
    2118. 

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

  2119. 		$activeSuffix = '';
    2120. 

  2120. 

  2121. 		// Loop through the arguments
    2122. 

  2122. 		$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
    2123. 

  2123. 		foreach ($aArgs as $arg) {
    2124. 

  2124. 			$parsedComplex = self::_parseComplex($arg);
    2125. 

  2125. 

  2126. 			if ($activeSuffix == '') {
    2127. 

  2127. 				$activeSuffix = $parsedComplex['suffix'];
    2128. 

  2128. 			} elseif (($parsedComplex['suffix'] != '') && ($activeSuffix != $parsedComplex['suffix'])) {
    2129. 

  2129. 				return PHPExcel_Calculation_Functions::VALUE();
    2130. 

  2130. 			}
    2131. 

  2131. 

  2132. 			$returnValue['real'] += $parsedComplex['real'];
    2133. 

  2133. 			$returnValue['imaginary'] += $parsedComplex['imaginary'];
    2134. 

  2134. 		}
    2135. 

  2135. 

  2136. 		if ($returnValue['imaginary'] == 0.0) { $activeSuffix = ''; }
    2137. 

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

  2138. 	}	//	function IMSUM()
    2139. 

  2139. 

  2140. 

  2141. 	/**
    2142. 

  2142. 	 * IMPRODUCT
    2143. 

  2143. 	 *
    2144. 

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

  2145. 	 *
    2146. 

  2146. 	 * Excel Function:
    2147. 

  2147. 	 *		IMPRODUCT(complexNumber[,complexNumber[,...]])
    2148. 

  2148. 	 *
    2149. 

  2149. 	 * @param	string		$complexNumber,...	Series of complex numbers to multiply
    2150. 

  2150. 	 * @return	string
    2151. 

  2151. 	 */
    2152. 

  2152. 	public static function IMPRODUCT() {
    2153. 

  2153. 		// Return value
    2154. 

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

  2155. 		$activeSuffix = '';
    2156. 

  2156. 

  2157. 		// Loop through the arguments
    2158. 

  2158. 		$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
    2159. 

  2159. 		foreach ($aArgs as $arg) {
    2160. 

  2160. 			$parsedComplex = self::_parseComplex($arg);
    2161. 

  2161. 

  2162. 			$workValue = $returnValue;
    2163. 

  2163. 			if (($parsedComplex['suffix'] != '') && ($activeSuffix == '')) {
    2164. 

  2164. 				$activeSuffix = $parsedComplex['suffix'];
    2165. 

  2165. 			} elseif (($parsedComplex['suffix'] != '') && ($activeSuffix != $parsedComplex['suffix'])) {
    2166. 

  2166. 				return PHPExcel_Calculation_Functions::NaN();
    2167. 

  2167. 			}
    2168. 

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

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

  2170. 		}
    2171. 

  2171. 

  2172. 		if ($returnValue['imaginary'] == 0.0) { $activeSuffix = ''; }
    2173. 

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

  2174. 	}	//	function IMPRODUCT()
    2175. 

  2175. 

  2176. 

  2177. 	/**
    2178. 

  2178. 	 *	DELTA
    2179. 

  2179. 	 *
    2180. 

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

  2181. 	 *	Use this function to filter a set of values. For example, by summing several DELTA
    2182. 

  2182. 	 *	functions you calculate the count of equal pairs. This function is also known as the
    2183. 

  2183. 	 *	Kronecker Delta function.
    2184. 

  2184. 	 *
    2185. 

  2185. 	 *	Excel Function:
    2186. 

  2186. 	 *		DELTA(a[,b])
    2187. 

  2187. 	 *
    2188. 

  2188. 	 *	@param	float		$a	The first number.
    2189. 

  2189. 	 *	@param	float		$b	The second number. If omitted, b is assumed to be zero.
    2190. 

  2190. 	 *	@return	int
    2191. 

  2191. 	 */
    2192. 

  2192. 	public static function DELTA($a, $b=0) {
    2193. 

  2193. 		$a	= PHPExcel_Calculation_Functions::flattenSingleValue($a);
    2194. 

  2194. 		$b	= PHPExcel_Calculation_Functions::flattenSingleValue($b);
    2195. 

  2195. 

  2196. 		return (int) ($a == $b);
    2197. 

  2197. 	}	//	function DELTA()
    2198. 

  2198. 

  2199. 

  2200. 	/**
    2201. 

  2201. 	 *	GESTEP
    2202. 

  2202. 	 *
    2203. 

  2203. 	 *	Excel Function:
    2204. 

  2204. 	 *		GESTEP(number[,step])
    2205. 

  2205. 	 *
    2206. 

  2206. 	 *	Returns 1 if number >= step; returns 0 (zero) otherwise
    2207. 

  2207. 	 *	Use this function to filter a set of values. For example, by summing several GESTEP
    2208. 

  2208. 	 *	functions you calculate the count of values that exceed a threshold.
    2209. 

  2209. 	 *
    2210. 

  2210. 	 *	@param	float		$number		The value to test against step.
    2211. 

  2211. 	 *	@param	float		$step		The threshold value.
    2212. 

  2212. 	 *									If you omit a value for step, GESTEP uses zero.
    2213. 

  2213. 	 *	@return	int
    2214. 

  2214. 	 */
    2215. 

  2215. 	public static function GESTEP($number, $step=0) {
    2216. 

  2216. 		$number	= PHPExcel_Calculation_Functions::flattenSingleValue($number);
    2217. 

  2217. 		$step	= PHPExcel_Calculation_Functions::flattenSingleValue($step);
    2218. 

  2218. 

  2219. 		return (int) ($number >= $step);
    2220. 

  2220. 	}	//	function GESTEP()
    2221. 

  2221. 

  2222. 

  2223. 	//
    2224. 

  2224. 	//	Private method to calculate the erf value
    2225. 

  2225. 	//
    2226. 

  2226. 	private static $_two_sqrtpi = 1.128379167095512574;
    2227. 

  2227. 

  2228. 	public static function _erfVal($x) {
    2229. 

  2229. 		if (abs($x) > 2.2) {
    2230. 

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

  2231. 		}
    2232. 

  2232. 		$sum = $term = $x;
    2233. 

  2233. 		$xsqr = ($x * $x);
    2234. 

  2234. 		$j = 1;
    2235. 

  2235. 		do {
    2236. 

  2236. 			$term *= $xsqr / $j;
    2237. 

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

  2238. 			++$j;
    2239. 

  2239. 			$term *= $xsqr / $j;
    2240. 

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

  2241. 			++$j;
    2242. 

  2242. 			if ($sum == 0.0) {
    2243. 

  2243. 				break;
    2244. 

  2244. 			}
    2245. 

  2245. 		} while (abs($term / $sum) > PRECISION);
    2246. 

  2246. 		return self::$_two_sqrtpi * $sum;
    2247. 

  2247. 	}	//	function _erfVal()
    2248. 

  2248. 

  2249. 

  2250. 	/**
    2251. 

  2251. 	 *	ERF
    2252. 

  2252. 	 *
    2253. 

  2253. 	 *	Returns the error function integrated between the lower and upper bound arguments.
    2254. 

  2254. 	 *
    2255. 

  2255. 	 *	Note: In Excel 2007 or earlier, if you input a negative value for the upper or lower bound arguments,
    2256. 

  2256. 	 *			the function would return a #NUM! error. However, in Excel 2010, the function algorithm was
    2257. 

  2257. 	 *			improved, so that it can now calculate the function for both positive and negative ranges.
    2258. 

  2258. 	 *			PHPExcel follows Excel 2010 behaviour, and accepts nagative arguments.
    2259. 

  2259. 	 *
    2260. 

  2260. 	 *	Excel Function:
    2261. 

  2261. 	 *		ERF(lower[,upper])
    2262. 

  2262. 	 *
    2263. 

  2263. 	 *	@param	float		$lower	lower bound for integrating ERF
    2264. 

  2264. 	 *	@param	float		$upper	upper bound for integrating ERF.
    2265. 

  2265. 	 *								If omitted, ERF integrates between zero and lower_limit
    2266. 

  2266. 	 *	@return	float
    2267. 

  2267. 	 */
    2268. 

  2268. 	public static function ERF($lower, $upper = NULL) {
    2269. 

  2269. 		$lower	= PHPExcel_Calculation_Functions::flattenSingleValue($lower);
    2270. 

  2270. 		$upper	= PHPExcel_Calculation_Functions::flattenSingleValue($upper);
    2271. 

  2271. 

  2272. 		if (is_numeric($lower)) {
    2273. 

  2273. 			if (is_null($upper)) {
    2274. 

  2274. 				return self::_erfVal($lower);
    2275. 

  2275. 			}
    2276. 

  2276. 			if (is_numeric($upper)) {
    2277. 

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

  2278. 			}
    2279. 

  2279. 		}
    2280. 

  2280. 		return PHPExcel_Calculation_Functions::VALUE();
    2281. 

  2281. 	}	//	function ERF()
    2282. 

  2282. 

  2283. 

  2284. 	//
    2285. 

  2285. 	//	Private method to calculate the erfc value
    2286. 

  2286. 	//
    2287. 

  2287. 	private static $_one_sqrtpi = 0.564189583547756287;
    2288. 

  2288. 

  2289. 	private static function _erfcVal($x) {
    2290. 

  2290. 		if (abs($x) < 2.2) {
    2291. 

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

  2292. 		}
    2293. 

  2293. 		if ($x < 0) {
    2294. 

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

  2295. 		}
    2296. 

  2296. 		$a = $n = 1;
    2297. 

  2297. 		$b = $c = $x;
    2298. 

  2298. 		$d = ($x * $x) + 0.5;
    2299. 

  2299. 		$q1 = $q2 = $b / $d;
    2300. 

  2300. 		$t = 0;
    2301. 

  2301. 		do {
    2302. 

  2302. 			$t = $a * $n + $b * $x;
    2303. 

  2303. 			$a = $b;
    2304. 

  2304. 			$b = $t;
    2305. 

  2305. 			$t = $c * $n + $d * $x;
    2306. 

  2306. 			$c = $d;
    2307. 

  2307. 			$d = $t;
    2308. 

  2308. 			$n += 0.5;
    2309. 

  2309. 			$q1 = $q2;
    2310. 

  2310. 			$q2 = $b / $d;
    2311. 

  2311. 		} while ((abs($q1 - $q2) / $q2) > PRECISION);
    2312. 

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

  2313. 	}	//	function _erfcVal()
    2314. 

  2314. 

  2315. 

  2316. 	/**
    2317. 

  2317. 	 *	ERFC
    2318. 

  2318. 	 *
    2319. 

  2319. 	 *	Returns the complementary ERF function integrated between x and infinity
    2320. 

  2320. 	 *
    2321. 

  2321. 	 *	Note: In Excel 2007 or earlier, if you input a negative value for the lower bound argument,
    2322. 

  2322. 	 *		the function would return a #NUM! error. However, in Excel 2010, the function algorithm was
    2323. 

  2323. 	 *		improved, so that it can now calculate the function for both positive and negative x values.
    2324. 

  2324. 	 *			PHPExcel follows Excel 2010 behaviour, and accepts nagative arguments.
    2325. 

  2325. 	 *
    2326. 

  2326. 	 *	Excel Function:
    2327. 

  2327. 	 *		ERFC(x)
    2328. 

  2328. 	 *
    2329. 

  2329. 	 *	@param	float	$x	The lower bound for integrating ERFC
    2330. 

  2330. 	 *	@return	float
    2331. 

  2331. 	 */
    2332. 

  2332. 	public static function ERFC($x) {
    2333. 

  2333. 		$x = PHPExcel_Calculation_Functions::flattenSingleValue($x);
    2334. 

  2334. 

  2335. 		if (is_numeric($x)) {
    2336. 

  2336. 			return self::_erfcVal($x);
    2337. 

  2337. 		}
    2338. 

  2338. 		return PHPExcel_Calculation_Functions::VALUE();
    2339. 

  2339. 	}	//	function ERFC()
    2340. 

  2340. 

  2341. 

  2342. 	/**
    2343. 

  2343. 	 *	getConversionGroups
    2344. 

  2344. 	 *	Returns a list of the different conversion groups for UOM conversions
    2345. 

  2345. 	 *
    2346. 

  2346. 	 *	@return	array
    2347. 

  2347. 	 */
    2348. 

  2348. 	public static function getConversionGroups() {
    2349. 

  2349. 		$conversionGroups = array();
    2350. 

  2350. 		foreach(self::$_conversionUnits as $conversionUnit) {
    2351. 

  2351. 			$conversionGroups[] = $conversionUnit['Group'];
    2352. 

  2352. 		}
    2353. 

  2353. 		return array_merge(array_unique($conversionGroups));
    2354. 

  2354. 	}	//	function getConversionGroups()
    2355. 

  2355. 

  2356. 

  2357. 	/**
    2358. 

  2358. 	 *	getConversionGroupUnits
    2359. 

  2359. 	 *	Returns an array of units of measure, for a specified conversion group, or for all groups
    2360. 

  2360. 	 *
    2361. 

  2361. 	 *	@param	string	$group	The group whose units of measure you want to retrieve
    2362. 

  2362. 	 *	@return	array
    2363. 

  2363. 	 */
    2364. 

  2364. 	public static function getConversionGroupUnits($group = NULL) {
    2365. 

  2365. 		$conversionGroups = array();
    2366. 

  2366. 		foreach(self::$_conversionUnits as $conversionUnit => $conversionGroup) {
    2367. 

  2367. 			if ((is_null($group)) || ($conversionGroup['Group'] == $group)) {
    2368. 

  2368. 				$conversionGroups[$conversionGroup['Group']][] = $conversionUnit;
    2369. 

  2369. 			}
    2370. 

  2370. 		}
    2371. 

  2371. 		return $conversionGroups;
    2372. 

  2372. 	}	//	function getConversionGroupUnits()
    2373. 

  2373. 

  2374. 

  2375. 	/**
    2376. 

  2376. 	 *	getConversionGroupUnitDetails
    2377. 

  2377. 	 *
    2378. 

  2378. 	 *	@param	string	$group	The group whose units of measure you want to retrieve
    2379. 

  2379. 	 *	@return	array
    2380. 

  2380. 	 */
    2381. 

  2381. 	public static function getConversionGroupUnitDetails($group = NULL) {
    2382. 

  2382. 		$conversionGroups = array();
    2383. 

  2383. 		foreach(self::$_conversionUnits as $conversionUnit => $conversionGroup) {
    2384. 

  2384. 			if ((is_null($group)) || ($conversionGroup['Group'] == $group)) {
    2385. 

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

  2386. 																		'description'	=> $conversionGroup['Unit Name']
    2387. 

  2387. 																	  );
    2388. 

  2388. 			}
    2389. 

  2389. 		}
    2390. 

  2390. 		return $conversionGroups;
    2391. 

  2391. 	}	//	function getConversionGroupUnitDetails()
    2392. 

  2392. 

  2393. 

  2394. 	/**
    2395. 

  2395. 	 *	getConversionMultipliers
    2396. 

  2396. 	 *	Returns an array of the Multiplier prefixes that can be used with Units of Measure in CONVERTUOM()
    2397. 

  2397. 	 *
    2398. 

  2398. 	 *	@return	array of mixed
    2399. 

  2399. 	 */
    2400. 

  2400. 	public static function getConversionMultipliers() {
    2401. 

  2401. 		return self::$_conversionMultipliers;
    2402. 

  2402. 	}	//	function getConversionGroups()
    2403. 

  2403. 

  2404. 

  2405. 	/**
    2406. 

  2406. 	 *	CONVERTUOM
    2407. 

  2407. 	 *
    2408. 

  2408. 	 *	Converts a number from one measurement system to another.
    2409. 

  2409. 	 *	For example, CONVERT can translate a table of distances in miles to a table of distances
    2410. 

  2410. 	 *	in kilometers.
    2411. 

  2411. 	 *
    2412. 

  2412. 	 *	Excel Function:
    2413. 

  2413. 	 *		CONVERT(value,fromUOM,toUOM)
    2414. 

  2414. 	 *
    2415. 

  2415. 	 *	@param	float		$value		The value in fromUOM to convert.
    2416. 

  2416. 	 *	@param	string		$fromUOM	The units for value.
    2417. 

  2417. 	 *	@param	string		$toUOM		The units for the result.
    2418. 

  2418. 	 *
    2419. 

  2419. 	 *	@return	float
    2420. 

  2420. 	 */
    2421. 

  2421. 	public static function CONVERTUOM($value, $fromUOM, $toUOM) {
    2422. 

  2422. 		$value		= PHPExcel_Calculation_Functions::flattenSingleValue($value);
    2423. 

  2423. 		$fromUOM	= PHPExcel_Calculation_Functions::flattenSingleValue($fromUOM);
    2424. 

  2424. 		$toUOM		= PHPExcel_Calculation_Functions::flattenSingleValue($toUOM);
    2425. 

  2425. 

  2426. 		if (!is_numeric($value)) {
    2427. 

  2427. 			return PHPExcel_Calculation_Functions::VALUE();
    2428. 

  2428. 		}
    2429. 

  2429. 		$fromMultiplier = 1.0;
    2430. 

  2430. 		if (isset(self::$_conversionUnits[$fromUOM])) {
    2431. 

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

  2432. 		} else {
    2433. 

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

  2434. 			$fromUOM = substr($fromUOM,1);
    2435. 

  2435. 			if (isset(self::$_conversionMultipliers[$fromMultiplier])) {
    2436. 

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

  2437. 			} else {
    2438. 

  2438. 				return PHPExcel_Calculation_Functions::NA();
    2439. 

  2439. 			}
    2440. 

  2440. 			if ((isset(self::$_conversionUnits[$fromUOM])) && (self::$_conversionUnits[$fromUOM]['AllowPrefix'])) {
    2441. 

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

  2442. 			} else {
    2443. 

  2443. 				return PHPExcel_Calculation_Functions::NA();
    2444. 

  2444. 			}
    2445. 

  2445. 		}
    2446. 

  2446. 		$value *= $fromMultiplier;
    2447. 

  2447. 

  2448. 		$toMultiplier = 1.0;
    2449. 

  2449. 		if (isset(self::$_conversionUnits[$toUOM])) {
    2450. 

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

  2451. 		} else {
    2452. 

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

  2453. 			$toUOM = substr($toUOM,1);
    2454. 

  2454. 			if (isset(self::$_conversionMultipliers[$toMultiplier])) {
    2455. 

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

  2456. 			} else {
    2457. 

  2457. 				return PHPExcel_Calculation_Functions::NA();
    2458. 

  2458. 			}
    2459. 

  2459. 			if ((isset(self::$_conversionUnits[$toUOM])) && (self::$_conversionUnits[$toUOM]['AllowPrefix'])) {
    2460. 

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

  2461. 			} else {
    2462. 

  2462. 				return PHPExcel_Calculation_Functions::NA();
    2463. 

  2463. 			}
    2464. 

  2464. 		}
    2465. 

  2465. 		if ($unitGroup1 != $unitGroup2) {
    2466. 

  2466. 			return PHPExcel_Calculation_Functions::NA();
    2467. 

  2467. 		}
    2468. 

  2468. 

  2469. 		if (($fromUOM == $toUOM) && ($fromMultiplier == $toMultiplier)) {
    2470. 

  2470. 			//	We've already factored $fromMultiplier into the value, so we need
    2471. 

  2471. 			//		to reverse it again
    2472. 

  2472. 			return $value / $fromMultiplier;
    2473. 

  2473. 		} elseif ($unitGroup1 == 'Temperature') {
    2474. 

  2474. 			if (($fromUOM == 'F') || ($fromUOM == 'fah')) {
    2475. 

  2475. 				if (($toUOM == 'F') || ($toUOM == 'fah')) {
    2476. 

  2476. 					return $value;
    2477. 

  2477. 				} else {
    2478. 

  2478. 					$value = (($value - 32) / 1.8);
    2479. 

  2479. 					if (($toUOM == 'K') || ($toUOM == 'kel')) {
    2480. 

  2480. 						$value += 273.15;
    2481. 

  2481. 					}
    2482. 

  2482. 					return $value;
    2483. 

  2483. 				}
    2484. 

  2484. 			} elseif ((($fromUOM == 'K') || ($fromUOM == 'kel')) &&
    2485. 

  2485. 					  (($toUOM == 'K') || ($toUOM == 'kel'))) {
    2486. 

  2486. 						return $value;
    2487. 

  2487. 			} elseif ((($fromUOM == 'C') || ($fromUOM == 'cel')) &&
    2488. 

  2488. 					  (($toUOM == 'C') || ($toUOM == 'cel'))) {
    2489. 

  2489. 					return $value;
    2490. 

  2490. 			}
    2491. 

  2491. 			if (($toUOM == 'F') || ($toUOM == 'fah')) {
    2492. 

  2492. 				if (($fromUOM == 'K') || ($fromUOM == 'kel')) {
    2493. 

  2493. 					$value -= 273.15;
    2494. 

  2494. 				}
    2495. 

  2495. 				return ($value * 1.8) + 32;
    2496. 

  2496. 			}
    2497. 

  2497. 			if (($toUOM == 'C') || ($toUOM == 'cel')) {
    2498. 

  2498. 				return $value - 273.15;
    2499. 

  2499. 			}
    2500. 

  2500. 			return $value + 273.15;
    2501. 

  2501. 		}
    2502. 

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

  2503. 	}	//	function CONVERTUOM()
    2504. 

  2504. 

  2505. }	//	class PHPExcel_Calculation_Engineering
    2506. 

  2506.