PageRenderTime 51ms CodeModel.GetById 9ms RepoModel.GetById 0ms app.codeStats 1ms

/saf/lib/Ext/PHPExcel/Calculation/Engineering.php

https://github.com/lux/sitellite
PHP | 2174 lines | 1563 code | 210 blank | 401 comment | 339 complexity | a900301b65939c4e8ed8bdf7ed621695 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.1, Apache-2.0, GPL-3.0 
    

  1. <?php
    2. 

  2. /**
    3. 

  3.  * PHPExcel
    4. 

  4.  *
    5. 

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

  6.  *
    7. 

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

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

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

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

  11.  *
    12. 

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

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

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

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

  16.  *
    17. 

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

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

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

  20.  *
    21. 

  21.  * @category	PHPExcel
    22. 

  22.  * @package		PHPExcel_Calculation
    23. 

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

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

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

  26.  */
    27. 

  27. 

  28. 

  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 - 2011 PHPExcel (http://www.codeplex.com/PHPExcel)
    49. 

  49.  */
    50. 

  50. class PHPExcel_Calculation_Engineering {
    51. 

  51. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  115. 											);
    116. 

  116. 

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

  118. 													'Z'	=> array(	'multiplier'	=> 1E21,	'name'	=> 'zetta'	),
    119. 

  119. 													'E'	=> array(	'multiplier'	=> 1E18,	'name'	=> 'exa'	),
    120. 

  120. 													'P'	=> array(	'multiplier'	=> 1E15,	'name'	=> 'peta'	),
    121. 

  121. 													'T'	=> array(	'multiplier'	=> 1E12,	'name'	=> 'tera'	),
    122. 

  122. 													'G'	=> array(	'multiplier'	=> 1E9,		'name'	=> 'giga'	),
    123. 

  123. 													'M'	=> array(	'multiplier'	=> 1E6,		'name'	=> 'mega'	),
    124. 

  124. 													'k'	=> array(	'multiplier'	=> 1E3,		'name'	=> 'kilo'	),
    125. 

  125. 													'h'	=> array(	'multiplier'	=> 1E2,		'name'	=> 'hecto'	),
    126. 

  126. 													'e'	=> array(	'multiplier'	=> 1E1,		'name'	=> 'deka'	),
    127. 

  127. 													'd'	=> array(	'multiplier'	=> 1E-1,	'name'	=> 'deci'	),
    128. 

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

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

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

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

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

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

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

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

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

  137. 												 );
    138. 

  138. 

  139. 	private static $_unitConversions = array(	'Mass'		=> array(	'g'		=> array(	'g'		=> 1.0,
    140. 

  140. 																							'sg'	=> 6.85220500053478E-05,
    141. 

  141. 																							'lbm'	=> 2.20462291469134E-03,
    142. 

  142. 																							'u'		=> 6.02217000000000E+23,
    143. 

  143. 																							'ozm'	=> 3.52739718003627E-02
    144. 

  144. 																						),
    145. 

  145. 																		'sg'	=> array(	'g'		=> 1.45938424189287E+04,
    146. 

  146. 																							'sg'	=> 1.0,
    147. 

  147. 																							'lbm'	=> 3.21739194101647E+01,
    148. 

  148. 																							'u'		=> 8.78866000000000E+27,
    149. 

  149. 																							'ozm'	=> 5.14782785944229E+02
    150. 

  150. 																						),
    151. 

  151. 																		'lbm'	=> array(	'g'		=> 4.5359230974881148E+02,
    152. 

  152. 																							'sg'	=> 3.10810749306493E-02,
    153. 

  153. 																							'lbm'	=> 1.0,
    154. 

  154. 																							'u'		=> 2.73161000000000E+26,
    155. 

  155. 																							'ozm'	=> 1.60000023429410E+01
    156. 

  156. 																						),
    157. 

  157. 																		'u'		=> array(	'g'		=> 1.66053100460465E-24,
    158. 

  158. 																							'sg'	=> 1.13782988532950E-28,
    159. 

  159. 																							'lbm'	=> 3.66084470330684E-27,
    160. 

  160. 																							'u'		=> 1.0,
    161. 

  161. 																							'ozm'	=> 5.85735238300524E-26
    162. 

  162. 																						),
    163. 

  163. 																		'ozm'	=> array(	'g'		=> 2.83495152079732E+01,
    164. 

  164. 																							'sg'	=> 1.94256689870811E-03,
    165. 

  165. 																							'lbm'	=> 6.24999908478882E-02,
    166. 

  166. 																							'u'		=> 1.70725600000000E+25,
    167. 

  167. 																							'ozm'	=> 1.0
    168. 

  168. 																						)
    169. 

  169. 																	),
    170. 

  170. 												'Distance'	=> array(	'm'		=> array(	'm'		=> 1.0,
    171. 

  171. 																							'mi'	=> 6.21371192237334E-04,
    172. 

  172. 																							'Nmi'	=> 5.39956803455724E-04,
    173. 

  173. 																							'in'	=> 3.93700787401575E+01,
    174. 

  174. 																							'ft'	=> 3.28083989501312E+00,
    175. 

  175. 																							'yd'	=> 1.09361329797891E+00,
    176. 

  176. 																							'ang'	=> 1.00000000000000E+10,
    177. 

  177. 																							'Pica'	=> 2.83464566929116E+03
    178. 

  178. 																						),
    179. 

  179. 																		'mi'	=> array(	'm'		=> 1.60934400000000E+03,
    180. 

  180. 																							'mi'	=> 1.0,
    181. 

  181. 																							'Nmi'	=> 8.68976241900648E-01,
    182. 

  182. 																							'in'	=> 6.33600000000000E+04,
    183. 

  183. 																							'ft'	=> 5.28000000000000E+03,
    184. 

  184. 																							'yd'	=> 1.76000000000000E+03,
    185. 

  185. 																							'ang'	=> 1.60934400000000E+13,
    186. 

  186. 																							'Pica'	=> 4.56191999999971E+06
    187. 

  187. 																						),
    188. 

  188. 																		'Nmi'	=> array(	'm'		=> 1.85200000000000E+03,
    189. 

  189. 																							'mi'	=> 1.15077944802354E+00,
    190. 

  190. 																							'Nmi'	=> 1.0,
    191. 

  191. 																							'in'	=> 7.29133858267717E+04,
    192. 

  192. 																							'ft'	=> 6.07611548556430E+03,
    193. 

  193. 																							'yd'	=> 2.02537182785694E+03,
    194. 

  194. 																							'ang'	=> 1.85200000000000E+13,
    195. 

  195. 																							'Pica'	=> 5.24976377952723E+06
    196. 

  196. 																						),
    197. 

  197. 																		'in'	=> array(	'm'		=> 2.54000000000000E-02,
    198. 

  198. 																							'mi'	=> 1.57828282828283E-05,
    199. 

  199. 																							'Nmi'	=> 1.37149028077754E-05,
    200. 

  200. 																							'in'	=> 1.0,
    201. 

  201. 																							'ft'	=> 8.33333333333333E-02,
    202. 

  202. 																							'yd'	=> 2.77777777686643E-02,
    203. 

  203. 																							'ang'	=> 2.54000000000000E+08,
    204. 

  204. 																							'Pica'	=> 7.19999999999955E+01
    205. 

  205. 																						),
    206. 

  206. 																		'ft'	=> array(	'm'		=> 3.04800000000000E-01,
    207. 

  207. 																							'mi'	=> 1.89393939393939E-04,
    208. 

  208. 																							'Nmi'	=> 1.64578833693305E-04,
    209. 

  209. 																							'in'	=> 1.20000000000000E+01,
    210. 

  210. 																							'ft'	=> 1.0,
    211. 

  211. 																							'yd'	=> 3.33333333223972E-01,
    212. 

  212. 																							'ang'	=> 3.04800000000000E+09,
    213. 

  213. 																							'Pica'	=> 8.63999999999946E+02
    214. 

  214. 																						),
    215. 

  215. 																		'yd'	=> array(	'm'		=> 9.14400000300000E-01,
    216. 

  216. 																							'mi'	=> 5.68181818368230E-04,
    217. 

  217. 																							'Nmi'	=> 4.93736501241901E-04,
    218. 

  218. 																							'in'	=> 3.60000000118110E+01,
    219. 

  219. 																							'ft'	=> 3.00000000000000E+00,
    220. 

  220. 																							'yd'	=> 1.0,
    221. 

  221. 																							'ang'	=> 9.14400000300000E+09,
    222. 

  222. 																							'Pica'	=> 2.59200000085023E+03
    223. 

  223. 																						),
    224. 

  224. 																		'ang'	=> array(	'm'		=> 1.00000000000000E-10,
    225. 

  225. 																							'mi'	=> 6.21371192237334E-14,
    226. 

  226. 																							'Nmi'	=> 5.39956803455724E-14,
    227. 

  227. 																							'in'	=> 3.93700787401575E-09,
    228. 

  228. 																							'ft'	=> 3.28083989501312E-10,
    229. 

  229. 																							'yd'	=> 1.09361329797891E-10,
    230. 

  230. 																							'ang'	=> 1.0,
    231. 

  231. 																							'Pica'	=> 2.83464566929116E-07
    232. 

  232. 																						),
    233. 

  233. 																		'Pica'	=> array(	'm'		=> 3.52777777777800E-04,
    234. 

  234. 																							'mi'	=> 2.19205948372629E-07,
    235. 

  235. 																							'Nmi'	=> 1.90484761219114E-07,
    236. 

  236. 																							'in'	=> 1.38888888888898E-02,
    237. 

  237. 																							'ft'	=> 1.15740740740748E-03,
    238. 

  238. 																							'yd'	=> 3.85802469009251E-04,
    239. 

  239. 																							'ang'	=> 3.52777777777800E+06,
    240. 

  240. 																							'Pica'	=> 1.0
    241. 

  241. 																						)
    242. 

  242. 																	),
    243. 

  243. 												'Time'		=> array(	'yr'	=> array(	'yr'		=> 1.0,
    244. 

  244. 																							'day'		=> 365.25,
    245. 

  245. 																							'hr'		=> 8766.0,
    246. 

  246. 																							'mn'		=> 525960.0,
    247. 

  247. 																							'sec'		=> 31557600.0
    248. 

  248. 																						),
    249. 

  249. 																		'day'	=> array(	'yr'		=> 2.73785078713210E-03,
    250. 

  250. 																							'day'		=> 1.0,
    251. 

  251. 																							'hr'		=> 24.0,
    252. 

  252. 																							'mn'		=> 1440.0,
    253. 

  253. 																							'sec'		=> 86400.0
    254. 

  254. 																						),
    255. 

  255. 																		'hr'	=> array(	'yr'		=> 1.14077116130504E-04,
    256. 

  256. 																							'day'		=> 4.16666666666667E-02,
    257. 

  257. 																							'hr'		=> 1.0,
    258. 

  258. 																							'mn'		=> 60.0,
    259. 

  259. 																							'sec'		=> 3600.0
    260. 

  260. 																						),
    261. 

  261. 																		'mn'	=> array(	'yr'		=> 1.90128526884174E-06,
    262. 

  262. 																							'day'		=> 6.94444444444444E-04,
    263. 

  263. 																							'hr'		=> 1.66666666666667E-02,
    264. 

  264. 																							'mn'		=> 1.0,
    265. 

  265. 																							'sec'		=> 60.0
    266. 

  266. 																						),
    267. 

  267. 																		'sec'	=> array(	'yr'		=> 3.16880878140289E-08,
    268. 

  268. 																							'day'		=> 1.15740740740741E-05,
    269. 

  269. 																							'hr'		=> 2.77777777777778E-04,
    270. 

  270. 																							'mn'		=> 1.66666666666667E-02,
    271. 

  271. 																							'sec'		=> 1.0
    272. 

  272. 																						)
    273. 

  273. 																	),
    274. 

  274. 												'Pressure'	=> array(	'Pa'	=> array(	'Pa'		=> 1.0,
    275. 

  275. 																							'p'			=> 1.0,
    276. 

  276. 																							'atm'		=> 9.86923299998193E-06,
    277. 

  277. 																							'at'		=> 9.86923299998193E-06,
    278. 

  278. 																							'mmHg'		=> 7.50061707998627E-03
    279. 

  279. 																						),
    280. 

  280. 																		'p'		=> array(	'Pa'		=> 1.0,
    281. 

  281. 																							'p'			=> 1.0,
    282. 

  282. 																							'atm'		=> 9.86923299998193E-06,
    283. 

  283. 																							'at'		=> 9.86923299998193E-06,
    284. 

  284. 																							'mmHg'		=> 7.50061707998627E-03
    285. 

  285. 																						),
    286. 

  286. 																		'atm'	=> array(	'Pa'		=> 1.01324996583000E+05,
    287. 

  287. 																							'p'			=> 1.01324996583000E+05,
    288. 

  288. 																							'atm'		=> 1.0,
    289. 

  289. 																							'at'		=> 1.0,
    290. 

  290. 																							'mmHg'		=> 760.0
    291. 

  291. 																						),
    292. 

  292. 																		'at'	=> array(	'Pa'		=> 1.01324996583000E+05,
    293. 

  293. 																							'p'			=> 1.01324996583000E+05,
    294. 

  294. 																							'atm'		=> 1.0,
    295. 

  295. 																							'at'		=> 1.0,
    296. 

  296. 																							'mmHg'		=> 760.0
    297. 

  297. 																						),
    298. 

  298. 																		'mmHg'	=> array(	'Pa'		=> 1.33322363925000E+02,
    299. 

  299. 																							'p'			=> 1.33322363925000E+02,
    300. 

  300. 																							'atm'		=> 1.31578947368421E-03,
    301. 

  301. 																							'at'		=> 1.31578947368421E-03,
    302. 

  302. 																							'mmHg'		=> 1.0
    303. 

  303. 																						)
    304. 

  304. 																	),
    305. 

  305. 												'Force'		=> array(	'N'		=> array(	'N'			=> 1.0,
    306. 

  306. 																							'dyn'		=> 1.0E+5,
    307. 

  307. 																							'dy'		=> 1.0E+5,
    308. 

  308. 																							'lbf'		=> 2.24808923655339E-01
    309. 

  309. 																						),
    310. 

  310. 																		'dyn'	=> array(	'N'			=> 1.0E-5,
    311. 

  311. 																							'dyn'		=> 1.0,
    312. 

  312. 																							'dy'		=> 1.0,
    313. 

  313. 																							'lbf'		=> 2.24808923655339E-06
    314. 

  314. 																						),
    315. 

  315. 																		'dy'	=> array(	'N'			=> 1.0E-5,
    316. 

  316. 																							'dyn'		=> 1.0,
    317. 

  317. 																							'dy'		=> 1.0,
    318. 

  318. 																							'lbf'		=> 2.24808923655339E-06
    319. 

  319. 																						),
    320. 

  320. 																		'lbf'	=> array(	'N'			=> 4.448222,
    321. 

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

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

  323. 																							'lbf'		=> 1.0
    324. 

  324. 																						)
    325. 

  325. 																	),
    326. 

  326. 												'Energy'	=> array(	'J'		=> array(	'J'			=> 1.0,
    327. 

  327. 																							'e'			=> 9.99999519343231E+06,
    328. 

  328. 																							'c'			=> 2.39006249473467E-01,
    329. 

  329. 																							'cal'		=> 2.38846190642017E-01,
    330. 

  330. 																							'eV'		=> 6.24145700000000E+18,
    331. 

  331. 																							'ev'		=> 6.24145700000000E+18,
    332. 

  332. 																							'HPh'		=> 3.72506430801000E-07,
    333. 

  333. 																							'hh'		=> 3.72506430801000E-07,
    334. 

  334. 																							'Wh'		=> 2.77777916238711E-04,
    335. 

  335. 																							'wh'		=> 2.77777916238711E-04,
    336. 

  336. 																							'flb'		=> 2.37304222192651E+01,
    337. 

  337. 																							'BTU'		=> 9.47815067349015E-04,
    338. 

  338. 																							'btu'		=> 9.47815067349015E-04
    339. 

  339. 																						),
    340. 

  340. 																		'e'		=> array(	'J'			=> 1.00000048065700E-07,
    341. 

  341. 																							'e'			=> 1.0,
    342. 

  342. 																							'c'			=> 2.39006364353494E-08,
    343. 

  343. 																							'cal'		=> 2.38846305445111E-08,
    344. 

  344. 																							'eV'		=> 6.24146000000000E+11,
    345. 

  345. 																							'ev'		=> 6.24146000000000E+11,
    346. 

  346. 																							'HPh'		=> 3.72506609848824E-14,
    347. 

  347. 																							'hh'		=> 3.72506609848824E-14,
    348. 

  348. 																							'Wh'		=> 2.77778049754611E-11,
    349. 

  349. 																							'wh'		=> 2.77778049754611E-11,
    350. 

  350. 																							'flb'		=> 2.37304336254586E-06,
    351. 

  351. 																							'BTU'		=> 9.47815522922962E-11,
    352. 

  352. 																							'btu'		=> 9.47815522922962E-11
    353. 

  353. 																						),
    354. 

  354. 																		'c'		=> array(	'J'			=> 4.18399101363672E+00,
    355. 

  355. 																							'e'			=> 4.18398900257312E+07,
    356. 

  356. 																							'c'			=> 1.0,
    357. 

  357. 																							'cal'		=> 9.99330315287563E-01,
    358. 

  358. 																							'eV'		=> 2.61142000000000E+19,
    359. 

  359. 																							'ev'		=> 2.61142000000000E+19,
    360. 

  360. 																							'HPh'		=> 1.55856355899327E-06,
    361. 

  361. 																							'hh'		=> 1.55856355899327E-06,
    362. 

  362. 																							'Wh'		=> 1.16222030532950E-03,
    363. 

  363. 																							'wh'		=> 1.16222030532950E-03,
    364. 

  364. 																							'flb'		=> 9.92878733152102E+01,
    365. 

  365. 																							'BTU'		=> 3.96564972437776E-03,
    366. 

  366. 																							'btu'		=> 3.96564972437776E-03
    367. 

  367. 																						),
    368. 

  368. 																		'cal'	=> array(	'J'			=> 4.18679484613929E+00,
    369. 

  369. 																							'e'			=> 4.18679283372801E+07,
    370. 

  370. 																							'c'			=> 1.00067013349059E+00,
    371. 

  371. 																							'cal'		=> 1.0,
    372. 

  372. 																							'eV'		=> 2.61317000000000E+19,
    373. 

  373. 																							'ev'		=> 2.61317000000000E+19,
    374. 

  374. 																							'HPh'		=> 1.55960800463137E-06,
    375. 

  375. 																							'hh'		=> 1.55960800463137E-06,
    376. 

  376. 																							'Wh'		=> 1.16299914807955E-03,
    377. 

  377. 																							'wh'		=> 1.16299914807955E-03,
    378. 

  378. 																							'flb'		=> 9.93544094443283E+01,
    379. 

  379. 																							'BTU'		=> 3.96830723907002E-03,
    380. 

  380. 																							'btu'		=> 3.96830723907002E-03
    381. 

  381. 																						),
    382. 

  382. 																		'eV'	=> array(	'J'			=> 1.60219000146921E-19,
    383. 

  383. 																							'e'			=> 1.60218923136574E-12,
    384. 

  384. 																							'c'			=> 3.82933423195043E-20,
    385. 

  385. 																							'cal'		=> 3.82676978535648E-20,
    386. 

  386. 																							'eV'		=> 1.0,
    387. 

  387. 																							'ev'		=> 1.0,
    388. 

  388. 																							'HPh'		=> 5.96826078912344E-26,
    389. 

  389. 																							'hh'		=> 5.96826078912344E-26,
    390. 

  390. 																							'Wh'		=> 4.45053000026614E-23,
    391. 

  391. 																							'wh'		=> 4.45053000026614E-23,
    392. 

  392. 																							'flb'		=> 3.80206452103492E-18,
    393. 

  393. 																							'BTU'		=> 1.51857982414846E-22,
    394. 

  394. 																							'btu'		=> 1.51857982414846E-22
    395. 

  395. 																						),
    396. 

  396. 																		'ev'	=> array(	'J'			=> 1.60219000146921E-19,
    397. 

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

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

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

  400. 																							'eV'		=> 1.0,
    401. 

  401. 																							'ev'		=> 1.0,
    402. 

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

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

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

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

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

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

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

  409. 																						),
    410. 

  410. 																		'HPh'	=> array(	'J'			=> 2.68451741316170E+06,
    411. 

  411. 																							'e'			=> 2.68451612283024E+13,
    412. 

  412. 																							'c'			=> 6.41616438565991E+05,
    413. 

  413. 																							'cal'		=> 6.41186757845835E+05,
    414. 

  414. 																							'eV'		=> 1.67553000000000E+25,
    415. 

  415. 																							'ev'		=> 1.67553000000000E+25,
    416. 

  416. 																							'HPh'		=> 1.0,
    417. 

  417. 																							'hh'		=> 1.0,
    418. 

  418. 																							'Wh'		=> 7.45699653134593E+02,
    419. 

  419. 																							'wh'		=> 7.45699653134593E+02,
    420. 

  420. 																							'flb'		=> 6.37047316692964E+07,
    421. 

  421. 																							'BTU'		=> 2.54442605275546E+03,
    422. 

  422. 																							'btu'		=> 2.54442605275546E+03
    423. 

  423. 																						),
    424. 

  424. 																		'hh'	=> array(	'J'			=> 2.68451741316170E+06,
    425. 

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

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

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

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

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

  430. 																							'HPh'		=> 1.0,
    431. 

  431. 																							'hh'		=> 1.0,
    432. 

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

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

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

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

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

  437. 																						),
    438. 

  438. 																		'Wh'	=> array(	'J'			=> 3.59999820554720E+03,
    439. 

  439. 																							'e'			=> 3.59999647518369E+10,
    440. 

  440. 																							'c'			=> 8.60422069219046E+02,
    441. 

  441. 																							'cal'		=> 8.59845857713046E+02,
    442. 

  442. 																							'eV'		=> 2.24692340000000E+22,
    443. 

  443. 																							'ev'		=> 2.24692340000000E+22,
    444. 

  444. 																							'HPh'		=> 1.34102248243839E-03,
    445. 

  445. 																							'hh'		=> 1.34102248243839E-03,
    446. 

  446. 																							'Wh'		=> 1.0,
    447. 

  447. 																							'wh'		=> 1.0,
    448. 

  448. 																							'flb'		=> 8.54294774062316E+04,
    449. 

  449. 																							'BTU'		=> 3.41213254164705E+00,
    450. 

  450. 																							'btu'		=> 3.41213254164705E+00
    451. 

  451. 																						),
    452. 

  452. 																		'wh'	=> array(	'J'			=> 3.59999820554720E+03,
    453. 

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

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

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

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

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

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

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

  460. 																							'Wh'		=> 1.0,
    461. 

  461. 																							'wh'		=> 1.0,
    462. 

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

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

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

  465. 																						),
    466. 

  466. 																		'flb'	=> array(	'J'			=> 4.21400003236424E-02,
    467. 

  467. 																							'e'			=> 4.21399800687660E+05,
    468. 

  468. 																							'c'			=> 1.00717234301644E-02,
    469. 

  469. 																							'cal'		=> 1.00649785509554E-02,
    470. 

  470. 																							'eV'		=> 2.63015000000000E+17,
    471. 

  471. 																							'ev'		=> 2.63015000000000E+17,
    472. 

  472. 																							'HPh'		=> 1.56974211145130E-08,
    473. 

  473. 																							'hh'		=> 1.56974211145130E-08,
    474. 

  474. 																							'Wh'		=> 1.17055614802000E-05,
    475. 

  475. 																							'wh'		=> 1.17055614802000E-05,
    476. 

  476. 																							'flb'		=> 1.0,
    477. 

  477. 																							'BTU'		=> 3.99409272448406E-05,
    478. 

  478. 																							'btu'		=> 3.99409272448406E-05
    479. 

  479. 																						),
    480. 

  480. 																		'BTU'	=> array(	'J'			=> 1.05505813786749E+03,
    481. 

  481. 																							'e'			=> 1.05505763074665E+10,
    482. 

  482. 																							'c'			=> 2.52165488508168E+02,
    483. 

  483. 																							'cal'		=> 2.51996617135510E+02,
    484. 

  484. 																							'eV'		=> 6.58510000000000E+21,
    485. 

  485. 																							'ev'		=> 6.58510000000000E+21,
    486. 

  486. 																							'HPh'		=> 3.93015941224568E-04,
    487. 

  487. 																							'hh'		=> 3.93015941224568E-04,
    488. 

  488. 																							'Wh'		=> 2.93071851047526E-01,
    489. 

  489. 																							'wh'		=> 2.93071851047526E-01,
    490. 

  490. 																							'flb'		=> 2.50369750774671E+04,
    491. 

  491. 																							'BTU'		=> 1.0,
    492. 

  492. 																							'btu'		=> 1.0,
    493. 

  493. 																						),
    494. 

  494. 																		'btu'	=> array(	'J'			=> 1.05505813786749E+03,
    495. 

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

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

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

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

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

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

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

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

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

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

  505. 																							'BTU'		=> 1.0,
    506. 

  506. 																							'btu'		=> 1.0,
    507. 

  507. 																						)
    508. 

  508. 																	),
    509. 

  509. 												'Power'		=> array(	'HP'	=> array(	'HP'		=> 1.0,
    510. 

  510. 																							'h'			=> 1.0,
    511. 

  511. 																							'W'			=> 7.45701000000000E+02,
    512. 

  512. 																							'w'			=> 7.45701000000000E+02
    513. 

  513. 																						),
    514. 

  514. 																		'h'		=> array(	'HP'		=> 1.0,
    515. 

  515. 																							'h'			=> 1.0,
    516. 

  516. 																							'W'			=> 7.45701000000000E+02,
    517. 

  517. 																							'w'			=> 7.45701000000000E+02
    518. 

  518. 																						),
    519. 

  519. 																		'W'		=> array(	'HP'		=> 1.34102006031908E-03,
    520. 

  520. 																							'h'			=> 1.34102006031908E-03,
    521. 

  521. 																							'W'			=> 1.0,
    522. 

  522. 																							'w'			=> 1.0
    523. 

  523. 																						),
    524. 

  524. 																		'w'		=> array(	'HP'		=> 1.34102006031908E-03,
    525. 

  525. 																							'h'			=> 1.34102006031908E-03,
    526. 

  526. 																							'W'			=> 1.0,
    527. 

  527. 																							'w'			=> 1.0
    528. 

  528. 																						)
    529. 

  529. 																	),
    530. 

  530. 												'Magnetism'	=> array(	'T'		=> array(	'T'			=> 1.0,
    531. 

  531. 																							'ga'		=> 10000.0
    532. 

  532. 																						),
    533. 

  533. 																		'ga'	=> array(	'T'			=> 0.0001,
    534. 

  534. 																							'ga'		=> 1.0
    535. 

  535. 																						)
    536. 

  536. 																	),
    537. 

  537. 												'Liquid'	=> array(	'tsp'	=> array(	'tsp'		=> 1.0,
    538. 

  538. 																							'tbs'		=> 3.33333333333333E-01,
    539. 

  539. 																							'oz'		=> 1.66666666666667E-01,
    540. 

  540. 																							'cup'		=> 2.08333333333333E-02,
    541. 

  541. 																							'pt'		=> 1.04166666666667E-02,
    542. 

  542. 																							'us_pt'		=> 1.04166666666667E-02,
    543. 

  543. 																							'uk_pt'		=> 8.67558516821960E-03,
    544. 

  544. 																							'qt'		=> 5.20833333333333E-03,
    545. 

  545. 																							'gal'		=> 1.30208333333333E-03,
    546. 

  546. 																							'l'			=> 4.92999408400710E-03,
    547. 

  547. 																							'lt'		=> 4.92999408400710E-03
    548. 

  548. 																						),
    549. 

  549. 																		'tbs'	=> array(	'tsp'		=> 3.00000000000000E+00,
    550. 

  550. 																							'tbs'		=> 1.0,
    551. 

  551. 																							'oz'		=> 5.00000000000000E-01,
    552. 

  552. 																							'cup'		=> 6.25000000000000E-02,
    553. 

  553. 																							'pt'		=> 3.12500000000000E-02,
    554. 

  554. 																							'us_pt'		=> 3.12500000000000E-02,
    555. 

  555. 																							'uk_pt'		=> 2.60267555046588E-02,
    556. 

  556. 																							'qt'		=> 1.56250000000000E-02,
    557. 

  557. 																							'gal'		=> 3.90625000000000E-03,
    558. 

  558. 																							'l'			=> 1.47899822520213E-02,
    559. 

  559. 																							'lt'		=> 1.47899822520213E-02
    560. 

  560. 																						),
    561. 

  561. 																		'oz'	=> array(	'tsp'		=> 6.00000000000000E+00,
    562. 

  562. 																							'tbs'		=> 2.00000000000000E+00,
    563. 

  563. 																							'oz'		=> 1.0,
    564. 

  564. 																							'cup'		=> 1.25000000000000E-01,
    565. 

  565. 																							'pt'		=> 6.25000000000000E-02,
    566. 

  566. 																							'us_pt'		=> 6.25000000000000E-02,
    567. 

  567. 																							'uk_pt'		=> 5.20535110093176E-02,
    568. 

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

  569. 																							'gal'		=> 7.81250000000000E-03,
    570. 

  570. 																							'l'			=> 2.95799645040426E-02,
    571. 

  571. 																							'lt'		=> 2.95799645040426E-02
    572. 

  572. 																						),
    573. 

  573. 																		'cup'	=> array(	'tsp'		=> 4.80000000000000E+01,
    574. 

  574. 																							'tbs'		=> 1.60000000000000E+01,
    575. 

  575. 																							'oz'		=> 8.00000000000000E+00,
    576. 

  576. 																							'cup'		=> 1.0,
    577. 

  577. 																							'pt'		=> 5.00000000000000E-01,
    578. 

  578. 																							'us_pt'		=> 5.00000000000000E-01,
    579. 

  579. 																							'uk_pt'		=> 4.16428088074541E-01,
    580. 

  580. 																							'qt'		=> 2.50000000000000E-01,
    581. 

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

  582. 																							'l'			=> 2.36639716032341E-01,
    583. 

  583. 																							'lt'		=> 2.36639716032341E-01
    584. 

  584. 																						),
    585. 

  585. 																		'pt'	=> array(	'tsp'		=> 9.60000000000000E+01,
    586. 

  586. 																							'tbs'		=> 3.20000000000000E+01,
    587. 

  587. 																							'oz'		=> 1.60000000000000E+01,
    588. 

  588. 																							'cup'		=> 2.00000000000000E+00,
    589. 

  589. 																							'pt'		=> 1.0,
    590. 

  590. 																							'us_pt'		=> 1.0,
    591. 

  591. 																							'uk_pt'		=> 8.32856176149081E-01,
    592. 

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

  593. 																							'gal'		=> 1.25000000000000E-01,
    594. 

  594. 																							'l'			=> 4.73279432064682E-01,
    595. 

  595. 																							'lt'		=> 4.73279432064682E-01
    596. 

  596. 																						),
    597. 

  597. 																		'us_pt'	=> array(	'tsp'		=> 9.60000000000000E+01,
    598. 

  598. 																							'tbs'		=> 3.20000000000000E+01,
    599. 

  599. 																							'oz'		=> 1.60000000000000E+01,
    600. 

  600. 																							'cup'		=> 2.00000000000000E+00,
    601. 

  601. 																							'pt'		=> 1.0,
    602. 

  602. 																							'us_pt'		=> 1.0,
    603. 

  603. 																							'uk_pt'		=> 8.32856176149081E-01,
    604. 

  604. 																							'qt'		=> 5.00000000000000E-01,
    605. 

  605. 																							'gal'		=> 1.25000000000000E-01,
    606. 

  606. 																							'l'			=> 4.73279432064682E-01,
    607. 

  607. 																							'lt'		=> 4.73279432064682E-01
    608. 

  608. 																						),
    609. 

  609. 																		'uk_pt'	=> array(	'tsp'		=> 1.15266000000000E+02,
    610. 

  610. 																							'tbs'		=> 3.84220000000000E+01,
    611. 

  611. 																							'oz'		=> 1.92110000000000E+01,
    612. 

  612. 																							'cup'		=> 2.40137500000000E+00,
    613. 

  613. 																							'pt'		=> 1.20068750000000E+00,
    614. 

  614. 																							'us_pt'		=> 1.20068750000000E+00,
    615. 

  615. 																							'uk_pt'		=> 1.0,
    616. 

  616. 																							'qt'		=> 6.00343750000000E-01,
    617. 

  617. 																							'gal'		=> 1.50085937500000E-01,
    618. 

  618. 																							'l'			=> 5.68260698087162E-01,
    619. 

  619. 																							'lt'		=> 5.68260698087162E-01
    620. 

  620. 																						),
    621. 

  621. 																		'qt'	=> array(	'tsp'		=> 1.92000000000000E+02,
    622. 

  622. 																							'tbs'		=> 6.40000000000000E+01,
    623. 

  623. 																							'oz'		=> 3.20000000000000E+01,
    624. 

  624. 																							'cup'		=> 4.00000000000000E+00,
    625. 

  625. 																							'pt'		=> 2.00000000000000E+00,
    626. 

  626. 																							'us_pt'		=> 2.00000000000000E+00,
    627. 

  627. 																							'uk_pt'		=> 1.66571235229816E+00,
    628. 

  628. 																							'qt'		=> 1.0,
    629. 

  629. 																							'gal'		=> 2.50000000000000E-01,
    630. 

  630. 																							'l'			=> 9.46558864129363E-01,
    631. 

  631. 																							'lt'		=> 9.46558864129363E-01
    632. 

  632. 																						),
    633. 

  633. 																		'gal'	=> array(	'tsp'		=> 7.68000000000000E+02,
    634. 

  634. 																							'tbs'		=> 2.56000000000000E+02,
    635. 

  635. 																							'oz'		=> 1.28000000000000E+02,
    636. 

  636. 																							'cup'		=> 1.60000000000000E+01,
    637. 

  637. 																							'pt'		=> 8.00000000000000E+00,
    638. 

  638. 																							'us_pt'		=> 8.00000000000000E+00,
    639. 

  639. 																							'uk_pt'		=> 6.66284940919265E+00,
    640. 

  640. 																							'qt'		=> 4.00000000000000E+00,
    641. 

  641. 																							'gal'		=> 1.0,
    642. 

  642. 																							'l'			=> 3.78623545651745E+00,
    643. 

  643. 																							'lt'		=> 3.78623545651745E+00
    644. 

  644. 																						),
    645. 

  645. 																		'l'		=> array(	'tsp'		=> 2.02840000000000E+02,
    646. 

  646. 																							'tbs'		=> 6.76133333333333E+01,
    647. 

  647. 																							'oz'		=> 3.38066666666667E+01,
    648. 

  648. 																							'cup'		=> 4.22583333333333E+00,
    649. 

  649. 																							'pt'		=> 2.11291666666667E+00,
    650. 

  650. 																							'us_pt'		=> 2.11291666666667E+00,
    651. 

  651. 																							'uk_pt'		=> 1.75975569552166E+00,
    652. 

  652. 																							'qt'		=> 1.05645833333333E+00,
    653. 

  653. 																							'gal'		=> 2.64114583333333E-01,
    654. 

  654. 																							'l'			=> 1.0,
    655. 

  655. 																							'lt'		=> 1.0
    656. 

  656. 																						),
    657. 

  657. 																		'lt'	=> array(	'tsp'		=> 2.02840000000000E+02,
    658. 

  658. 																							'tbs'		=> 6.76133333333333E+01,
    659. 

  659. 																							'oz'		=> 3.38066666666667E+01,
    660. 

  660. 																							'cup'		=> 4.22583333333333E+00,
    661. 

  661. 																							'pt'		=> 2.11291666666667E+00,
    662. 

  662. 																							'us_pt'		=> 2.11291666666667E+00,
    663. 

  663. 																							'uk_pt'		=> 1.75975569552166E+00,
    664. 

  664. 																							'qt'		=> 1.05645833333333E+00,
    665. 

  665. 																							'gal'		=> 2.64114583333333E-01,
    666. 

  666. 																							'l'			=> 1.0,
    667. 

  667. 																							'lt'		=> 1.0
    668. 

  668. 																						)
    669. 

  669. 																	)
    670. 

  670. 											);
    671. 

  671. 

  672. 

  673. 	public static function _parseComplex($complexNumber) {
    674. 

  674. 		$workString = (string) $complexNumber;
    675. 

  675. 

  676. 		$realNumber = $imaginary = 0;
    677. 

  677. 		//	Extract the suffix, if there is one
    678. 

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

  679. 		if (!is_numeric($suffix)) {
    680. 

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

  681. 		} else {
    682. 

  682. 			$suffix = '';
    683. 

  683. 		}
    684. 

  684. 

  685. 		//	Split the input into its Real and Imaginary components
    686. 

  686. 		$leadingSign = 0;
    687. 

  687. 		if (strlen($workString) > 0) {
    688. 

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

  689. 		}
    690. 

  690. 		$power = '';
    691. 

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

  692. 		if (strtoupper(substr($realNumber,-1)) == 'E') {
    693. 

  693. 			$power = strtok('+-');
    694. 

  694. 			++$leadingSign;
    695. 

  695. 		}
    696. 

  696. 

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

  698. 

  699. 		if ($suffix != '') {
    700. 

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

  701. 

  702. 			if (($imaginary == '') && (($realNumber == '') || ($realNumber == '+') || ($realNumber == '-'))) {
    703. 

  703. 				$imaginary = $realNumber.'1';
    704. 

  704. 				$realNumber = '0';
    705. 

  705. 			} else if ($imaginary == '') {
    706. 

  706. 				$imaginary = $realNumber;
    707. 

  707. 				$realNumber = '0';
    708. 

  708. 			} elseif (($imaginary == '+') || ($imaginary == '-')) {
    709. 

  709. 				$imaginary .= '1';
    710. 

  710. 			}
    711. 

  711. 		}
    712. 

  712. 

  713. 		return array( 'real'		=> $realNumber,
    714. 

  714. 					  'imaginary'	=> $imaginary,
    715. 

  715. 					  'suffix'		=> $suffix
    716. 

  716. 					);
    717. 

  717. 	}	//	function _parseComplex()
    718. 

  718. 

  719. 

  720. 	private static function _cleanComplex($complexNumber) {
    721. 

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

  722. 		if ($complexNumber{0} == '0') $complexNumber = substr($complexNumber,1);
    723. 

  723. 		if ($complexNumber{0} == '.') $complexNumber = '0'.$complexNumber;
    724. 

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

  725. 		return $complexNumber;
    726. 

  726. 	}
    727. 

  727. 

  728. 

  729. 	private static function _nbrConversionFormat($xVal,$places) {
    730. 

  730. 		if (!is_null($places)) {
    731. 

  731. 			if (strlen($xVal) <= $places) {
    732. 

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

  733. 			} else {
    734. 

  734. 				return PHPExcel_Calculation_Functions::NaN();
    735. 

  735. 			}
    736. 

  736. 		}
    737. 

  737. 

  738. 		return substr($xVal,-10);
    739. 

  739. 	}	//	function _nbrConversionFormat()
    740. 

  740. 

  741. 

  742. 	/**
    743. 

  743. 	 * BESSELI
    744. 

  744. 	 *
    745. 

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

  746. 	 *
    747. 

  747. 	 * @param	float		$x
    748. 

  748. 	 * @param	float		$n
    749. 

  749. 	 * @return	int
    750. 

  750. 	 */
    751. 

  751. 	public static function BESSELI($x, $n) {
    752. 

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

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

  754. 

  755. 		if ((is_numeric($x)) && (is_numeric($n))) {
    756. 

  756. 			$n	= floor($n);
    757. 

  757. 			if ($n < 0) {
    758. 

  758. 				return PHPExcel_Calculation_Functions::NaN();
    759. 

  759. 			}
    760. 

  760. 			$f_2_PI = 2 * M_PI;
    761. 

  761. 

  762. 			if (abs($x) <= 30) {
    763. 

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

  764. 				$nK = 1;
    765. 

  765. 				$fResult = $fTerm;
    766. 

  766. 				$fSqrX = ($x * $x) / 4;
    767. 

  767. 				do {
    768. 

  768. 					$fTerm *= $fSqrX;
    769. 

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

  770. 					$fResult += $fTerm;
    771. 

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

  772. 			} else {
    773. 

  773. 				$fXAbs = abs($x);
    774. 

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

  775. 				if (($n && 1) && ($x < 0)) {
    776. 

  776. 					$fResult = -$fResult;
    777. 

  777. 				}
    778. 

  778. 			}
    779. 

  779. 			return $fResult;
    780. 

  780. 		}
    781. 

  781. 		return PHPExcel_Calculation_Functions::VALUE();
    782. 

  782. 	}	//	function BESSELI()
    783. 

  783. 

  784. 

  785. 	/**
    786. 

  786. 	 * BESSELJ
    787. 

  787. 	 *
    788. 

  788. 	 * Returns the Bessel function
    789. 

  789. 	 *
    790. 

  790. 	 * @param	float		$x
    791. 

  791. 	 * @param	float		$n
    792. 

  792. 	 * @return	int
    793. 

  793. 	 */
    794. 

  794. 	public static function BESSELJ($x, $n) {
    795. 

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

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

  797. 

  798. 		if ((is_numeric($x)) && (is_numeric($n))) {
    799. 

  799. 			$n	= floor($n);
    800. 

  800. 			if ($n < 0) {
    801. 

  801. 				return PHPExcel_Calculation_Functions::NaN();
    802. 

  802. 			}
    803. 

  803. 			$f_PI_DIV_2 = M_PI / 2;
    804. 

  804. 			$f_PI_DIV_4 = M_PI / 4;
    805. 

  805. 

  806. 			$fResult = 0;
    807. 

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

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

  809. 				$nK = 1;
    810. 

  810. 				$fResult = $fTerm;
    811. 

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

  812. 				do {
    813. 

  813. 					$fTerm *= $fSqrX;
    814. 

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

  815. 					$fResult += $fTerm;
    816. 

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

  817. 			} else {
    818. 

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

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

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

  821. 					$fResult = -$fResult;
    822. 

  822. 				}
    823. 

  823. 			}
    824. 

  824. 			return $fResult;
    825. 

  825. 		}
    826. 

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

  827. 	}	//	function BESSELJ()
    828. 

  828. 

  829. 

  830. 	private static function _Besselk0($fNum) {
    831. 

  831. 		if ($fNum <= 2) {
    832. 

  832. 			$fNum2 = $fNum * 0.5;
    833. 

  833. 			$y = ($fNum2 * $fNum2);
    834. 

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

  835. 					(-0.57721566 + $y * (0.42278420 + $y * (0.23069756 + $y * (0.3488590e-1 + $y * (0.262698e-2 + $y *
    836. 

  836. 					(0.10750e-3 + $y * 0.74e-5))))));
    837. 

  837. 		} else {
    838. 

  838. 			$y = 2 / $fNum;
    839. 

  839. 			$fRet = exp(-$fNum) / sqrt($fNum) *
    840. 

  840. 					(1.25331414 + $y * (-0.7832358e-1 + $y * (0.2189568e-1 + $y * (-0.1062446e-1 + $y *
    841. 

  841. 					(0.587872e-2 + $y * (-0.251540e-2 + $y * 0.53208e-3))))));
    842. 

  842. 		}
    843. 

  843. 		return $fRet;
    844. 

  844. 	}	//	function _Besselk0()
    845. 

  845. 

  846. 

  847. 	private static function _Besselk1($fNum) {
    848. 

  848. 		if ($fNum <= 2) {
    849. 

  849. 			$fNum2 = $fNum * 0.5;
    850. 

  850. 			$y = ($fNum2 * $fNum2);
    851. 

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

  852. 					(1 + $y * (0.15443144 + $y * (-0.67278579 + $y * (-0.18156897 + $y * (-0.1919402e-1 + $y *
    853. 

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

  854. 		} else {
    855. 

  855. 			$y = 2 / $fNum;
    856. 

  856. 			$fRet = exp(-$fNum) / sqrt($fNum) *
    857. 

  857. 					(1.25331414 + $y * (0.23498619 + $y * (-0.3655620e-1 + $y * (0.1504268e-1 + $y * (-0.780353e-2 + $y *
    858. 

  858. 					(0.325614e-2 + $y * (-0.68245e-3)))))));
    859. 

  859. 		}
    860. 

  860. 		return $fRet;
    861. 

  861. 	}	//	function _Besselk1()
    862. 

  862. 

  863. 

  864. 	/**
    865. 

  865. 	 * BESSELK
    866. 

  866. 	 *
    867. 

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

  868. 	 *
    869. 

  869. 	 * @param	float		$x
    870. 

  870. 	 * @param	float		$ord
    871. 

  871. 	 * @return	float
    872. 

  872. 	 */
    873. 

  873. 	public static function BESSELK($x, $ord) {
    874. 

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

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

  876. 

  877. 		if ((is_numeric($x)) && (is_numeric($ord))) {
    878. 

  878. 			if (($ord < 0) || ($x == 0.0)) {
    879. 

  879. 				return PHPExcel_Calculation_Functions::NaN();
    880. 

  880. 			}
    881. 

  881. 

  882. 			switch(floor($ord)) {
    883. 

  883. 				case 0 :	return self::_Besselk0($x);
    884. 

  884. 							break;
    885. 

  885. 				case 1 :	return self::_Besselk1($x);
    886. 

  886. 							break;
    887. 

  887. 				default :	$fTox	= 2 / $x;
    888. 

  888. 							$fBkm	= self::_Besselk0($x);
    889. 

  889. 							$fBk	= self::_Besselk1($x);
    890. 

  890. 							for ($n = 1; $n < $ord; ++$n) {
    891. 

  891. 								$fBkp	= $fBkm + $n * $fTox * $fBk;
    892. 

  892. 								$fBkm	= $fBk;
    893. 

  893. 								$fBk	= $fBkp;
    894. 

  894. 							}
    895. 

  895. 			}
    896. 

  896. 			return $fBk;
    897. 

  897. 		}
    898. 

  898. 		return PHPExcel_Calculation_Functions::VALUE();
    899. 

  899. 	}	//	function BESSELK()
    900. 

  900. 

  901. 

  902. 	private static function _Bessely0($fNum) {
    903. 

  903. 		if ($fNum < 8.0) {
    904. 

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

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

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

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

  908. 		} else {
    909. 

  909. 			$z = 8.0 / $fNum;
    910. 

  910. 			$y = ($z * $z);
    911. 

  911. 			$xx = $fNum - 0.785398164;
    912. 

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

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

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

  915. 		}
    916. 

  916. 		return $fRet;
    917. 

  917. 	}	//	function _Bessely0()
    918. 

  918. 

  919. 

  920. 	private static function _Bessely1($fNum) {
    921. 

  921. 		if ($fNum < 8.0) {
    922. 

  922. 			$y = ($fNum * $fNum);
    923. 

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

  924. 				(-0.4237922726e7 + $y * 0.8511937935e4)))));
    925. 

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

  926. 				(0.1020426050e6 + $y * (0.3549632885e3 + $y)))));
    927. 

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

  928. 		} else {
    929. 

  929. 			$z = 8.0 / $fNum;
    930. 

  930. 			$y = ($z * $z);
    931. 

  931. 			$xx = $fNum - 2.356194491;
    932. 

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

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

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

  935. 			#i12430# ...but this seems to work much better.
    936. 

  936. //			$fRet = sqrt(M_2DIVPI / $fNum) * sin($fNum - 2.356194491);
    937. 

  937. 		}
    938. 

  938. 		return $fRet;
    939. 

  939. 	}	//	function _Bessely1()
    940. 

  940. 

  941. 

  942. 	/**
    943. 

  943. 	 * BESSELY
    944. 

  944. 	 *
    945. 

  945. 	 * Returns the Bessel function, which is also called the Weber function or the Neumann function.
    946. 

  946. 	 *
    947. 

  947. 	 * @param	float		$x
    948. 

  948. 	 * @param	float		$n
    949. 

  949. 	 * @return	int
    950. 

  950. 	 */
    951. 

  951. 	public static function BESSELY($x, $ord) {
    952. 

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

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

  954. 

  955. 		if ((is_numeric($x)) && (is_numeric($ord))) {
    956. 

  956. 			if (($ord < 0) || ($x == 0.0)) {
    957. 

  957. 				return PHPExcel_Calculation_Functions::NaN();
    958. 

  958. 			}
    959. 

  959. 

  960. 			switch(floor($ord)) {
    961. 

  961. 				case 0 :	return self::_Bessely0($x);
    962. 

  962. 							break;
    963. 

  963. 				case 1 :	return self::_Bessely1($x);
    964. 

  964. 							break;
    965. 

  965. 				default:	$fTox	= 2 / $x;
    966. 

  966. 							$fBym	= self::_Bessely0($x);
    967. 

  967. 							$fBy	= self::_Bessely1($x);
    968. 

  968. 							for ($n = 1; $n < $ord; ++$n) {
    969. 

  969. 								$fByp	= $n * $fTox * $fBy - $fBym;
    970. 

  970. 								$fBym	= $fBy;
    971. 

  971. 								$fBy	= $fByp;
    972. 

  972. 							}
    973. 

  973. 			}
    974. 

  974. 			return $fBy;
    975. 

  975. 		}
    976. 

  976. 		return PHPExcel_Calculation_Functions::VALUE();
    977. 

  977. 	}	//	function BESSELY()
    978. 

  978. 

  979. 

  980. 	/**
    981. 

  981. 	 * BINTODEC
    982. 

  982. 	 *
    983. 

  983. 	 * Return a binary value as Decimal.
    984. 

  984. 	 *
    985. 

  985. 	 * @param	string		$x
    986. 

  986. 	 * @return	string
    987. 

  987. 	 */
    988. 

  988. 	public static function BINTODEC($x) {
    989. 

  989. 		$x	= PHPExcel_Calculation_Functions::flattenSingleValue($x);
    990. 

  990. 

  991. 		if (is_bool($x)) {
    992. 

  992. 			if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE) {
    993. 

  993. 				$x = (int) $x;
    994. 

  994. 			} else {
    995. 

  995. 				return PHPExcel_Calculation_Functions::VALUE();
    996. 

  996. 			}
    997. 

  997. 		}
    998. 

  998. 		if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC) {
    999. 

  999. 			$x = floor($x);
    1000. 

  1000. 		}
    1001. 

  1001. 		$x = (string) $x;
    1002. 

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

  1003. 			return PHPExcel_Calculation_Functions::NaN();
    1004. 

  1004. 		}
    1005. 

  1005. 		if (strlen($x) > 10) {
    1006. 

  1006. 			return PHPExcel_Calculation_Functions::NaN();
    1007. 

  1007. 		} elseif (strlen($x) == 10) {
    1008. 

  1008. 			//	Two's Complement
    1009. 

  1009. 			$x = substr($x,-9);
    1010. 

  1010. 			return '-'.(512-bindec($x));
    1011. 

  1011. 		}
    1012. 

  1012. 		return bindec($x);
    1013. 

  1013. 	}	//	function BINTODEC()
    1014. 

  1014. 

  1015. 

  1016. 	/**
    1017. 

  1017. 	 * BINTOHEX
    1018. 

  1018. 	 *
    1019. 

  1019. 	 * Return a binary value as Hex.
    1020. 

  1020. 	 *
    1021. 

  1021. 	 * @param	string		$x
    1022. 

  1022. 	 * @return	string
    1023. 

  1023. 	 */
    1024. 

  1024. 	public static function BINTOHEX($x, $places=null) {
    1025. 

  1025. 		$x	= floor(PHPExcel_Calculation_Functions::flattenSingleValue($x));
    1026. 

  1026. 		$places	= PHPExcel_Calculation_Functions::flattenSingleValue($places);
    1027. 

  1027. 

  1028. 		if (is_bool($x)) {
    1029. 

  1029. 			if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE) {
    1030. 

  1030. 				$x = (int) $x;
    1031. 

  1031. 			} else {
    1032. 

  1032. 				return PHPExcel_Calculation_Functions::VALUE();
    1033. 

  1033. 			}
    1034. 

  1034. 		}
    1035. 

  1035. 		if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC) {
    1036. 

  1036. 			$x = floor($x);
    1037. 

  1037. 		}
    1038. 

  1038. 		$x = (string) $x;
    1039. 

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

  1040. 			return PHPExcel_Calculation_Functions::NaN();
    1041. 

  1041. 		}
    1042. 

  1042. 		if (strlen($x) > 10) {
    1043. 

  1043. 			return PHPExcel_Calculation_Functions::NaN();
    1044. 

  1044. 		} elseif (strlen($x) == 10) {
    1045. 

  1045. 			//	Two's Complement
    1046. 

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

  1047. 		}
    1048. 

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

  1049. 

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

  1051. 	}	//	function BINTOHEX()
    1052. 

  1052. 

  1053. 

  1054. 	/**
    1055. 

  1055. 	 * BINTOOCT
    1056. 

  1056. 	 *
    1057. 

  1057. 	 * Return a binary value as Octal.
    1058. 

  1058. 	 *
    1059. 

  1059. 	 * @param	string		$x
    1060. 

  1060. 	 * @return	string
    1061. 

  1061. 	 */
    1062. 

  1062. 	public static function BINTOOCT($x, $places=null) {
    1063. 

  1063. 		$x	= floor(PHPExcel_Calculation_Functions::flattenSingleValue($x));
    1064. 

  1064. 		$places	= PHPExcel_Calculation_Functions::flattenSingleValue($places);
    1065. 

  1065. 

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

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

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

  1069. 			} else {
    1070. 

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

  1071. 			}
    1072. 

  1072. 		}
    1073. 

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

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

  1075. 		}
    1076. 

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

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

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

  1079. 		}
    1080. 

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

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

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

  1083. 			//	Two's Complement
    1084. 

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

  1085. 		}
    1086. 

  1086. 		$octVal = (string) decoct(bindec($x));
    1087. 

  1087. 

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

  1089. 	}	//	function BINTOOCT()
    1090. 

  1090. 

  1091. 

  1092. 	/**
    1093. 

  1093. 	 * DECTOBIN
    1094. 

  1094. 	 *
    1095. 

  1095. 	 * Return an octal value as binary.
    1096. 

  1096. 	 *
    1097. 

  1097. 	 * @param	string		$x
    1098. 

  1098. 	 * @return	string
    1099. 

  1099. 	 */
    1100. 

  1100. 	public static function DECTOBIN($x, $places=null) {
    1101. 

  1101. 		$x	= PHPExcel_Calculation_Functions::flattenSingleValue($x);
    1102. 

  1102. 		$places	= PHPExcel_Calculation_Functions::flattenSingleValue($places);
    1103. 

  1103. 

  1104. 		if (is_bool($x)) {
    1105. 

  1105. 			if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE) {
    1106. 

  1106. 				$x = (int) $x;
    1107. 

  1107. 			} else {
    1108. 

  1108. 				return PHPExcel_Calculation_Functions::VALUE();
    1109. 

  1109. 			}
    1110. 

  1110. 		}
    1111. 

  1111. 		$x = (string) $x;
    1112. 

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

  1113. 			return PHPExcel_Calculation_Functions::VALUE();
    1114. 

  1114. 		}
    1115. 

  1115. 		$x = (string) floor($x);
    1116. 

  1116. 		$r = decbin($x);
    1117. 

  1117. 		if (strlen($r) == 32) {
    1118. 

  1118. 			//	Two's Complement
    1119. 

  1119. 			$r = substr($r,-10);
    1120. 

  1120. 		} elseif (strlen($r) > 11) {
    1121. 

  1121. 			return PHPExcel_Calculation_Functions::NaN();
    1122. 

  1122. 		}
    1123. 

  1123. 

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

  1125. 	}	//	function DECTOBIN()
    1126. 

  1126. 

  1127. 

  1128. 	/**
    1129. 

  1129. 	 * DECTOHEX
    1130. 

  1130. 	 *
    1131. 

  1131. 	 * Return an octal value as binary.
    1132. 

  1132. 	 *
    1133. 

  1133. 	 * @param	string		$x
    1134. 

  1134. 	 * @return	string
    1135. 

  1135. 	 */
    1136. 

  1136. 	public static function DECTOHEX($x, $places=null) {
    1137. 

  1137. 		$x	= PHPExcel_Calculation_Functions::flattenSingleValue($x);
    1138. 

  1138. 		$places	= PHPExcel_Calculation_Functions::flattenSingleValue($places);
    1139. 

  1139. 

  1140. 		if (is_bool($x)) {
    1141. 

  1141. 			if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE) {
    1142. 

  1142. 				$x = (int) $x;
    1143. 

  1143. 			} else {
    1144. 

  1144. 				return PHPExcel_Calculation_Functions::VALUE();
    1145. 

  1145. 			}
    1146. 

  1146. 		}
    1147. 

  1147. 		$x = (string) $x;
    1148. 

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

  1149. 			return PHPExcel_Calculation_Functions::VALUE();
    1150. 

  1150. 		}
    1151. 

  1151. 		$x = (string) floor($x);
    1152. 

  1152. 		$r = strtoupper(dechex($x));
    1153. 

  1153. 		if (strlen($r) == 8) {
    1154. 

  1154. 			//	Two's Complement
    1155. 

  1155. 			$r = 'FF'.$r;
    1156. 

  1156. 		}
    1157. 

  1157. 

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

  1159. 	}	//	function DECTOHEX()
    1160. 

  1160. 

  1161. 

  1162. 	/**
    1163. 

  1163. 	 * DECTOOCT
    1164. 

  1164. 	 *
    1165. 

  1165. 	 * Return an octal value as binary.
    1166. 

  1166. 	 *
    1167. 

  1167. 	 * @param	string		$x
    1168. 

  1168. 	 * @return	string
    1169. 

  1169. 	 */
    1170. 

  1170. 	public static function DECTOOCT($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. 		$x = (string) $x;
    1182. 

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

  1183. 			return PHPExcel_Calculation_Functions::VALUE();
    1184. 

  1184. 		}
    1185. 

  1185. 		$x = (string) floor($x);
    1186. 

  1186. 		$r = decoct($x);
    1187. 

  1187. 		if (strlen($r) == 11) {
    1188. 

  1188. 			//	Two's Complement
    1189. 

  1189. 			$r = substr($r,-10);
    1190. 

  1190. 		}
    1191. 

  1191. 

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

  1193. 	}	//	function DECTOOCT()
    1194. 

  1194. 

  1195. 

  1196. 	/**
    1197. 

  1197. 	 * HEXTOBIN
    1198. 

  1198. 	 *
    1199. 

  1199. 	 * Return a hex value as binary.
    1200. 

  1200. 	 *
    1201. 

  1201. 	 * @param	string		$x
    1202. 

  1202. 	 * @return	string
    1203. 

  1203. 	 */
    1204. 

  1204. 	public static function HEXTOBIN($x, $places=null) {
    1205. 

  1205. 		$x	= PHPExcel_Calculation_Functions::flattenSingleValue($x);
    1206. 

  1206. 		$places	= PHPExcel_Calculation_Functions::flattenSingleValue($places);
    1207. 

  1207. 

  1208. 		if (is_bool($x)) {
    1209. 

  1209. 			return PHPExcel_Calculation_Functions::VALUE();
    1210. 

  1210. 		}
    1211. 

  1211. 		$x = (string) $x;
    1212. 

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

  1213. 			return PHPExcel_Calculation_Functions::NaN();
    1214. 

  1214. 		}
    1215. 

  1215. 		$binVal = decbin(hexdec($x));
    1216. 

  1216. 

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

  1218. 	}	//	function HEXTOBIN()
    1219. 

  1219. 

  1220. 

  1221. 	/**
    1222. 

  1222. 	 * HEXTODEC
    1223. 

  1223. 	 *
    1224. 

  1224. 	 * Return a hex value as octal.
    1225. 

  1225. 	 *
    1226. 

  1226. 	 * @param	string		$x
    1227. 

  1227. 	 * @return	string
    1228. 

  1228. 	 */
    1229. 

  1229. 	public static function HEXTODEC($x) {
    1230. 

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

  1231. 

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

  1233. 			return PHPExcel_Calculation_Functions::VALUE();
    1234. 

  1234. 		}
    1235. 

  1235. 		$x = (string) $x;
    1236. 

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

  1237. 			return PHPExcel_Calculation_Functions::NaN();
    1238. 

  1238. 		}
    1239. 

  1239. 		return hexdec($x);
    1240. 

  1240. 	}	//	function HEXTODEC()
    1241. 

  1241. 

  1242. 

  1243. 	/**
    1244. 

  1244. 	 * HEXTOOCT
    1245. 

  1245. 	 *
    1246. 

  1246. 	 * Return a hex value as octal.
    1247. 

  1247. 	 *
    1248. 

  1248. 	 * @param	string		$x
    1249. 

  1249. 	 * @return	string
    1250. 

  1250. 	 */
    1251. 

  1251. 	public static function HEXTOOCT($x, $places=null) {
    1252. 

  1252. 		$x	= PHPExcel_Calculation_Functions::flattenSingleValue($x);
    1253. 

  1253. 		$places	= PHPExcel_Calculation_Functions::flattenSingleValue($places);
    1254. 

  1254. 

  1255. 		if (is_bool($x)) {
    1256. 

  1256. 			return PHPExcel_Calculation_Functions::VALUE();
    1257. 

  1257. 		}
    1258. 

  1258. 		$x = (string) $x;
    1259. 

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

  1260. 			return PHPExcel_Calculation_Functions::NaN();
    1261. 

  1261. 		}
    1262. 

  1262. 		$octVal = decoct(hexdec($x));
    1263. 

  1263. 

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

  1265. 	}	//	function HEXTOOCT()
    1266. 

  1266. 

  1267. 

  1268. 	/**
    1269. 

  1269. 	 * OCTTOBIN
    1270. 

  1270. 	 *
    1271. 

  1271. 	 * Return an octal value as binary.
    1272. 

  1272. 	 *
    1273. 

  1273. 	 * @param	string		$x
    1274. 

  1274. 	 * @return	string
    1275. 

  1275. 	 */
    1276. 

  1276. 	public static function OCTTOBIN($x, $places=null) {
    1277. 

  1277. 		$x	= PHPExcel_Calculation_Functions::flattenSingleValue($x);
    1278. 

  1278. 		$places	= PHPExcel_Calculation_Functions::flattenSingleValue($places);
    1279. 

  1279. 

  1280. 		if (is_bool($x)) {
    1281. 

  1281. 			return PHPExcel_Calculation_Functions::VALUE();
    1282. 

  1282. 		}
    1283. 

  1283. 		$x = (string) $x;
    1284. 

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

  1285. 			return PHPExcel_Calculation_Functions::NaN();
    1286. 

  1286. 		}
    1287. 

  1287. 		$r = decbin(octdec($x));
    1288. 

  1288. 

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

  1290. 	}	//	function OCTTOBIN()
    1291. 

  1291. 

  1292. 

  1293. 	/**
    1294. 

  1294. 	 * OCTTODEC
    1295. 

  1295. 	 *
    1296. 

  1296. 	 * Return an octal value as binary.
    1297. 

  1297. 	 *
    1298. 

  1298. 	 * @param	string		$x
    1299. 

  1299. 	 * @return	string
    1300. 

  1300. 	 */
    1301. 

  1301. 	public static function OCTTODEC($x) {
    1302. 

  1302. 		$x	= PHPExcel_Calculation_Functions::flattenSingleValue($x);
    1303. 

  1303. 

  1304. 		if (is_bool($x)) {
    1305. 

  1305. 			return PHPExcel_Calculation_Functions::VALUE();
    1306. 

  1306. 		}
    1307. 

  1307. 		$x = (string) $x;
    1308. 

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

  1309. 			return PHPExcel_Calculation_Functions::NaN();
    1310. 

  1310. 		}
    1311. 

  1311. 		return octdec($x);
    1312. 

  1312. 	}	//	function OCTTODEC()
    1313. 

  1313. 

  1314. 

  1315. 	/**
    1316. 

  1316. 	 * OCTTOHEX
    1317. 

  1317. 	 *
    1318. 

  1318. 	 * Return an octal value as hex.
    1319. 

  1319. 	 *
    1320. 

  1320. 	 * @param	string		$x
    1321. 

  1321. 	 * @return	string
    1322. 

  1322. 	 */
    1323. 

  1323. 	public static function OCTTOHEX($x, $places=null) {
    1324. 

  1324. 		$x	= PHPExcel_Calculation_Functions::flattenSingleValue($x);
    1325. 

  1325. 		$places	= PHPExcel_Calculation_Functions::flattenSingleValue($places);
    1326. 

  1326. 

  1327. 		if (is_bool($x)) {
    1328. 

  1328. 			return PHPExcel_Calculation_Functions::VALUE();
    1329. 

  1329. 		}
    1330. 

  1330. 		$x = (string) $x;
    1331. 

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

  1332. 			return PHPExcel_Calculation_Functions::NaN();
    1333. 

  1333. 		}
    1334. 

  1334. 		$hexVal = strtoupper(dechex(octdec($x)));
    1335. 

  1335. 

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

  1337. 	}	//	function OCTTOHEX()
    1338. 

  1338. 

  1339. 

  1340. 	/**
    1341. 

  1341. 	 * COMPLEX
    1342. 

  1342. 	 *
    1343. 

  1343. 	 * returns a complex number of the form x + yi or x + yj.
    1344. 

  1344. 	 *
    1345. 

  1345. 	 * @param	float		$realNumber
    1346. 

  1346. 	 * @param	float		$imaginary
    1347. 

  1347. 	 * @param	string		$suffix
    1348. 

  1348. 	 * @return	string
    1349. 

  1349. 	 */
    1350. 

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

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

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

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

  1354. 

  1355. 		if (((is_numeric($realNumber)) && (is_numeric($imaginary))) &&
    1356. 

  1356. 			(($suffix == 'i') || ($suffix == 'j') || ($suffix == ''))) {
    1357. 

  1357. 			if ($suffix == '') $suffix = 'i';
    1358. 

  1358. 			if ($realNumber == 0.0) {
    1359. 

  1359. 				if ($imaginary == 0.0) {
    1360. 

  1360. 					return (string) '0';
    1361. 

  1361. 				} elseif ($imaginary == 1.0) {
    1362. 

  1362. 					return (string) $suffix;
    1363. 

  1363. 				} elseif ($imaginary == -1.0) {
    1364. 

  1364. 					return (string) '-'.$suffix;
    1365. 

  1365. 				}
    1366. 

  1366. 				return (string) $imaginary.$suffix;
    1367. 

  1367. 			} elseif ($imaginary == 0.0) {
    1368. 

  1368. 				return (string) $realNumber;
    1369. 

  1369. 			} elseif ($imaginary == 1.0) {
    1370. 

  1370. 				return (string) $realNumber.'+'.$suffix;
    1371. 

  1371. 			} elseif ($imaginary == -1.0) {
    1372. 

  1372. 				return (string) $realNumber.'-'.$suffix;
    1373. 

  1373. 			}
    1374. 

  1374. 			if ($imaginary > 0) { $imaginary = (string) '+'.$imaginary; }
    1375. 

  1375. 			return (string) $realNumber.$imaginary.$suffix;
    1376. 

  1376. 		}
    1377. 

  1377. 

  1378. 		return PHPExcel_Calculation_Functions::VALUE();
    1379. 

  1379. 	}	//	function COMPLEX()
    1380. 

  1380. 

  1381. 

  1382. 	/**
    1383. 

  1383. 	 * IMAGINARY
    1384. 

  1384. 	 *
    1385. 

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

  1386. 	 *
    1387. 

  1387. 	 * @param	string		$complexNumber
    1388. 

  1388. 	 * @return	real
    1389. 

  1389. 	 */
    1390. 

  1390. 	public static function IMAGINARY($complexNumber) {
    1391. 

  1391. 		$complexNumber	= PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
    1392. 

  1392. 

  1393. 		$parsedComplex = self::_parseComplex($complexNumber);
    1394. 

  1394. 		if (!is_array($parsedComplex)) {
    1395. 

  1395. 			return $parsedComplex;
    1396. 

  1396. 		}
    1397. 

  1397. 		return $parsedComplex['imaginary'];
    1398. 

  1398. 	}	//	function IMAGINARY()
    1399. 

  1399. 

  1400. 

  1401. 	/**
    1402. 

  1402. 	 * IMREAL
    1403. 

  1403. 	 *
    1404. 

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

  1405. 	 *
    1406. 

  1406. 	 * @param	string		$complexNumber
    1407. 

  1407. 	 * @return	real
    1408. 

  1408. 	 */
    1409. 

  1409. 	public static function IMREAL($complexNumber) {
    1410. 

  1410. 		$complexNumber	= PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
    1411. 

  1411. 

  1412. 		$parsedComplex = self::_parseComplex($complexNumber);
    1413. 

  1413. 		if (!is_array($parsedComplex)) {
    1414. 

  1414. 			return $parsedComplex;
    1415. 

  1415. 		}
    1416. 

  1416. 		return $parsedComplex['real'];
    1417. 

  1417. 	}	//	function IMREAL()
    1418. 

  1418. 

  1419. 

  1420. 	/**
    1421. 

  1421. 	 * IMABS
    1422. 

  1422. 	 *
    1423. 

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

  1424. 	 *
    1425. 

  1425. 	 * @param	string		$complexNumber
    1426. 

  1426. 	 * @return	real
    1427. 

  1427. 	 */
    1428. 

  1428. 	public static function IMABS($complexNumber) {
    1429. 

  1429. 		$complexNumber	= PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
    1430. 

  1430. 

  1431. 		$parsedComplex = self::_parseComplex($complexNumber);
    1432. 

  1432. 		if (!is_array($parsedComplex)) {
    1433. 

  1433. 			return $parsedComplex;
    1434. 

  1434. 		}
    1435. 

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

  1436. 	}	//	function IMABS()
    1437. 

  1437. 

  1438. 

  1439. 	/**
    1440. 

  1440. 	 * IMARGUMENT
    1441. 

  1441. 	 *
    1442. 

  1442. 	 * Returns the argument theta of a complex number, i.e. the angle in radians from the real axis to the representation of the number in polar coordinates.
    1443. 

  1443. 	 *
    1444. 

  1444. 	 * @param	string		$complexNumber
    1445. 

  1445. 	 * @return	string
    1446. 

  1446. 	 */
    1447. 

  1447. 	public static function IMARGUMENT($complexNumber) {
    1448. 

  1448. 		$complexNumber	= PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
    1449. 

  1449. 

  1450. 		$parsedComplex = self::_parseComplex($complexNumber);
    1451. 

  1451. 		if (!is_array($parsedComplex)) {
    1452. 

  1452. 			return $parsedComplex;
    1453. 

  1453. 		}
    1454. 

  1454. 

  1455. 		if ($parsedComplex['real'] == 0.0) {
    1456. 

  1456. 			if ($parsedComplex['imaginary'] == 0.0) {
    1457. 

  1457. 				return 0.0;
    1458. 

  1458. 			} elseif($parsedComplex['imaginary'] < 0.0) {
    1459. 

  1459. 				return M_PI / -2;
    1460. 

  1460. 			} else {
    1461. 

  1461. 				return M_PI / 2;
    1462. 

  1462. 			}
    1463. 

  1463. 		} elseif ($parsedComplex['real'] > 0.0) {
    1464. 

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

  1465. 		} elseif ($parsedComplex['imaginary'] < 0.0) {
    1466. 

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

  1467. 		} else {
    1468. 

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

  1469. 		}
    1470. 

  1470. 	}	//	function IMARGUMENT()
    1471. 

  1471. 

  1472. 

  1473. 	/**
    1474. 

  1474. 	 * IMCONJUGATE
    1475. 

  1475. 	 *
    1476. 

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

  1477. 	 *
    1478. 

  1478. 	 * @param	string		$complexNumber
    1479. 

  1479. 	 * @return	string
    1480. 

  1480. 	 */
    1481. 

  1481. 	public static function IMCONJUGATE($complexNumber) {
    1482. 

  1482. 		$complexNumber	= PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
    1483. 

  1483. 

  1484. 		$parsedComplex = self::_parseComplex($complexNumber);
    1485. 

  1485. 

  1486. 		if (!is_array($parsedComplex)) {
    1487. 

  1487. 			return $parsedComplex;
    1488. 

  1488. 		}
    1489. 

  1489. 

  1490. 		if ($parsedComplex['imaginary'] == 0.0) {
    1491. 

  1491. 			return $parsedComplex['real'];
    1492. 

  1492. 		} else {
    1493. 

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

  1494. 		}
    1495. 

  1495. 	}	//	function IMCONJUGATE()
    1496. 

  1496. 

  1497. 

  1498. 	/**
    1499. 

  1499. 	 * IMCOS
    1500. 

  1500. 	 *
    1501. 

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

  1502. 	 *
    1503. 

  1503. 	 * @param	string		$complexNumber
    1504. 

  1504. 	 * @return	string
    1505. 

  1505. 	 */
    1506. 

  1506. 	public static function IMCOS($complexNumber) {
    1507. 

  1507. 		$complexNumber	= PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
    1508. 

  1508. 

  1509. 		$parsedComplex = self::_parseComplex($complexNumber);
    1510. 

  1510. 		if (!is_array($parsedComplex)) {
    1511. 

  1511. 			return $parsedComplex;
    1512. 

  1512. 		}
    1513. 

  1513. 

  1514. 		if ($parsedComplex['imaginary'] == 0.0) {
    1515. 

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

  1516. 		} else {
    1517. 

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

  1518. 		}
    1519. 

  1519. 	}	//	function IMCOS()
    1520. 

  1520. 

  1521. 

  1522. 	/**
    1523. 

  1523. 	 * IMSIN
    1524. 

  1524. 	 *
    1525. 

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

  1526. 	 *
    1527. 

  1527. 	 * @param	string		$complexNumber
    1528. 

  1528. 	 * @return	string
    1529. 

  1529. 	 */
    1530. 

  1530. 	public static function IMSIN($complexNumber) {
    1531. 

  1531. 		$complexNumber	= PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
    1532. 

  1532. 

  1533. 		$parsedComplex = self::_parseComplex($complexNumber);
    1534. 

  1534. 		if (!is_array($parsedComplex)) {
    1535. 

  1535. 			return $parsedComplex;
    1536. 

  1536. 		}
    1537. 

  1537. 

  1538. 		if ($parsedComplex['imaginary'] == 0.0) {
    1539. 

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

  1540. 		} else {
    1541. 

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

  1542. 		}
    1543. 

  1543. 	}	//	function IMSIN()
    1544. 

  1544. 

  1545. 

  1546. 	/**
    1547. 

  1547. 	 * IMSQRT
    1548. 

  1548. 	 *
    1549. 

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

  1550. 	 *
    1551. 

  1551. 	 * @param	string		$complexNumber
    1552. 

  1552. 	 * @return	string
    1553. 

  1553. 	 */
    1554. 

  1554. 	public static function IMSQRT($complexNumber) {
    1555. 

  1555. 		$complexNumber	= PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
    1556. 

  1556. 

  1557. 		$parsedComplex = self::_parseComplex($complexNumber);
    1558. 

  1558. 		if (!is_array($parsedComplex)) {
    1559. 

  1559. 			return $parsedComplex;
    1560. 

  1560. 		}
    1561. 

  1561. 

  1562. 		$theta = self::IMARGUMENT($complexNumber);
    1563. 

  1563. 		$d1 = cos($theta / 2);
    1564. 

  1564. 		$d2 = sin($theta / 2);
    1565. 

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

  1566. 

  1567. 		if ($parsedComplex['suffix'] == '') {
    1568. 

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

  1569. 		} else {
    1570. 

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

  1571. 		}
    1572. 

  1572. 	}	//	function IMSQRT()
    1573. 

  1573. 

  1574. 

  1575. 	/**
    1576. 

  1576. 	 * IMLN
    1577. 

  1577. 	 *
    1578. 

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

  1579. 	 *
    1580. 

  1580. 	 * @param	string		$complexNumber
    1581. 

  1581. 	 * @return	string
    1582. 

  1582. 	 */
    1583. 

  1583. 	public static function IMLN($complexNumber) {
    1584. 

  1584. 		$complexNumber	= PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
    1585. 

  1585. 

  1586. 		$parsedComplex = self::_parseComplex($complexNumber);
    1587. 

  1587. 		if (!is_array($parsedComplex)) {
    1588. 

  1588. 			return $parsedComplex;
    1589. 

  1589. 		}
    1590. 

  1590. 

  1591. 		if (($parsedComplex['real'] == 0.0) && ($parsedComplex['imaginary'] == 0.0)) {
    1592. 

  1592. 			return PHPExcel_Calculation_Functions::NaN();
    1593. 

  1593. 		}
    1594. 

  1594. 

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

  1596. 		$t = self::IMARGUMENT($complexNumber);
    1597. 

  1597. 

  1598. 		if ($parsedComplex['suffix'] == '') {
    1599. 

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

  1600. 		} else {
    1601. 

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

  1602. 		}
    1603. 

  1603. 	}	//	function IMLN()
    1604. 

  1604. 

  1605. 

  1606. 	/**
    1607. 

  1607. 	 * IMLOG10
    1608. 

  1608. 	 *
    1609. 

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

  1610. 	 *
    1611. 

  1611. 	 * @param	string		$complexNumber
    1612. 

  1612. 	 * @return	string
    1613. 

  1613. 	 */
    1614. 

  1614. 	public static function IMLOG10($complexNumber) {
    1615. 

  1615. 		$complexNumber	= PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
    1616. 

  1616. 

  1617. 		$parsedComplex = self::_parseComplex($complexNumber);
    1618. 

  1618. 		if (!is_array($parsedComplex)) {
    1619. 

  1619. 			return $parsedComplex;
    1620. 

  1620. 		}
    1621. 

  1621. 

  1622. 		if (($parsedComplex['real'] == 0.0) && ($parsedComplex['imaginary'] == 0.0)) {
    1623. 

  1623. 			return PHPExcel_Calculation_Functions::NaN();
    1624. 

  1624. 		} elseif (($parsedComplex['real'] > 0.0) && ($parsedComplex['imaginary'] == 0.0)) {
    1625. 

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

  1626. 		}
    1627. 

  1627. 

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

  1629. 	}	//	function IMLOG10()
    1630. 

  1630. 

  1631. 

  1632. 	/**
    1633. 

  1633. 	 * IMLOG2
    1634. 

  1634. 	 *
    1635. 

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

  1636. 	 *
    1637. 

  1637. 	 * @param	string		$complexNumber
    1638. 

  1638. 	 * @return	string
    1639. 

  1639. 	 */
    1640. 

  1640. 	public static function IMLOG2($complexNumber) {
    1641. 

  1641. 		$complexNumber	= PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
    1642. 

  1642. 

  1643. 		$parsedComplex = self::_parseComplex($complexNumber);
    1644. 

  1644. 		if (!is_array($parsedComplex)) {
    1645. 

  1645. 			return $parsedComplex;
    1646. 

  1646. 		}
    1647. 

  1647. 

  1648. 		if (($parsedComplex['real'] == 0.0) && ($parsedComplex['imaginary'] == 0.0)) {
    1649. 

  1649. 			return PHPExcel_Calculation_Functions::NaN();
    1650. 

  1650. 		} elseif (($parsedComplex['real'] > 0.0) && ($parsedComplex['imaginary'] == 0.0)) {
    1651. 

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

  1652. 		}
    1653. 

  1653. 

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

  1655. 	}	//	function IMLOG2()
    1656. 

  1656. 

  1657. 

  1658. 	/**
    1659. 

  1659. 	 * IMEXP
    1660. 

  1660. 	 *
    1661. 

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

  1662. 	 *
    1663. 

  1663. 	 * @param	string		$complexNumber
    1664. 

  1664. 	 * @return	string
    1665. 

  1665. 	 */
    1666. 

  1666. 	public static function IMEXP($complexNumber) {
    1667. 

  1667. 		$complexNumber	= PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
    1668. 

  1668. 

  1669. 		$parsedComplex = self::_parseComplex($complexNumber);
    1670. 

  1670. 		if (!is_array($parsedComplex)) {
    1671. 

  1671. 			return $parsedComplex;
    1672. 

  1672. 		}
    1673. 

  1673. 

  1674. 		if (($parsedComplex['real'] == 0.0) && ($parsedComplex['imaginary'] == 0.0)) {
    1675. 

  1675. 			return '1';
    1676. 

  1676. 		}
    1677. 

  1677. 

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

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

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

  1681. 

  1682. 		if ($parsedComplex['suffix'] == '') {
    1683. 

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

  1684. 		} else {
    1685. 

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

  1686. 		}
    1687. 

  1687. 	}	//	function IMEXP()
    1688. 

  1688. 

  1689. 

  1690. 	/**
    1691. 

  1691. 	 * IMPOWER
    1692. 

  1692. 	 *
    1693. 

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

  1694. 	 *
    1695. 

  1695. 	 * @param	string		$complexNumber
    1696. 

  1696. 	 * @return	string
    1697. 

  1697. 	 */
    1698. 

  1698. 	public static function IMPOWER($complexNumber,$realNumber) {
    1699. 

  1699. 		$complexNumber	= PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
    1700. 

  1700. 		$realNumber		= PHPExcel_Calculation_Functions::flattenSingleValue($realNumber);
    1701. 

  1701. 

  1702. 		if (!is_numeric($realNumber)) {
    1703. 

  1703. 			return PHPExcel_Calculation_Functions::VALUE();
    1704. 

  1704. 		}
    1705. 

  1705. 

  1706. 		$parsedComplex = self::_parseComplex($complexNumber);
    1707. 

  1707. 		if (!is_array($parsedComplex)) {
    1708. 

  1708. 			return $parsedComplex;
    1709. 

  1709. 		}
    1710. 

  1710. 

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

  1712. 		$rPower = pow($r,$realNumber);
    1713. 

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

  1714. 		if ($theta == 0) {
    1715. 

  1715. 			return 1;
    1716. 

  1716. 		} elseif ($parsedComplex['imaginary'] == 0.0) {
    1717. 

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

  1718. 		} else {
    1719. 

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

  1720. 		}
    1721. 

  1721. 	}	//	function IMPOWER()
    1722. 

  1722. 

  1723. 

  1724. 	/**
    1725. 

  1725. 	 * IMDIV
    1726. 

  1726. 	 *
    1727. 

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

  1728. 	 *
    1729. 

  1729. 	 * @param	string		$complexDividend
    1730. 

  1730. 	 * @param	string		$complexDivisor
    1731. 

  1731. 	 * @return	real
    1732. 

  1732. 	 */
    1733. 

  1733. 	public static function IMDIV($complexDividend,$complexDivisor) {
    1734. 

  1734. 		$complexDividend	= PHPExcel_Calculation_Functions::flattenSingleValue($complexDividend);
    1735. 

  1735. 		$complexDivisor	= PHPExcel_Calculation_Functions::flattenSingleValue($complexDivisor);
    1736. 

  1736. 

  1737. 		$parsedComplexDividend = self::_parseComplex($complexDividend);
    1738. 

  1738. 		if (!is_array($parsedComplexDividend)) {
    1739. 

  1739. 			return $parsedComplexDividend;
    1740. 

  1740. 		}
    1741. 

  1741. 

  1742. 		$parsedComplexDivisor = self::_parseComplex($complexDivisor);
    1743. 

  1743. 		if (!is_array($parsedComplexDivisor)) {
    1744. 

  1744. 			return $parsedComplexDividend;
    1745. 

  1745. 		}
    1746. 

  1746. 

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

  1748. 			($parsedComplexDividend['suffix'] != $parsedComplexDivisor['suffix'])) {
    1749. 

  1749. 			return PHPExcel_Calculation_Functions::NaN();
    1750. 

  1750. 		}
    1751. 

  1751. 		if (($parsedComplexDividend['suffix'] != '') && ($parsedComplexDivisor['suffix'] == '')) {
    1752. 

  1752. 			$parsedComplexDivisor['suffix'] = $parsedComplexDividend['suffix'];
    1753. 

  1753. 		}
    1754. 

  1754. 

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

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

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

  1758. 

  1759. 		$r = $d1/$d3;
    1760. 

  1760. 		$i = $d2/$d3;
    1761. 

  1761. 

  1762. 		if ($i > 0.0) {
    1763. 

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

  1764. 		} elseif ($i < 0.0) {
    1765. 

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

  1766. 		} else {
    1767. 

  1767. 			return $r;
    1768. 

  1768. 		}
    1769. 

  1769. 	}	//	function IMDIV()
    1770. 

  1770. 

  1771. 

  1772. 	/**
    1773. 

  1773. 	 * IMSUB
    1774. 

  1774. 	 *
    1775. 

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

  1776. 	 *
    1777. 

  1777. 	 * @param	string		$complexNumber1
    1778. 

  1778. 	 * @param	string		$complexNumber2
    1779. 

  1779. 	 * @return	real
    1780. 

  1780. 	 */
    1781. 

  1781. 	public static function IMSUB($complexNumber1,$complexNumber2) {
    1782. 

  1782. 		$complexNumber1	= PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber1);
    1783. 

  1783. 		$complexNumber2	= PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber2);
    1784. 

  1784. 

  1785. 		$parsedComplex1 = self::_parseComplex($complexNumber1);
    1786. 

  1786. 		if (!is_array($parsedComplex1)) {
    1787. 

  1787. 			return $parsedComplex1;
    1788. 

  1788. 		}
    1789. 

  1789. 

  1790. 		$parsedComplex2 = self::_parseComplex($complexNumber2);
    1791. 

  1791. 		if (!is_array($parsedComplex2)) {
    1792. 

  1792. 			return $parsedComplex2;
    1793. 

  1793. 		}
    1794. 

  1794. 

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

  1796. 			($parsedComplex1['suffix'] != $parsedComplex2['suffix'])) {
    1797. 

  1797. 			return PHPExcel_Calculation_Functions::NaN();
    1798. 

  1798. 		} elseif (($parsedComplex1['suffix'] == '') && ($parsedComplex2['suffix'] != '')) {
    1799. 

  1799. 			$parsedComplex1['suffix'] = $parsedComplex2['suffix'];
    1800. 

  1800. 		}
    1801. 

  1801. 

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

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

  1804. 

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

  1806. 	}	//	function IMSUB()
    1807. 

  1807. 

  1808. 

  1809. 	/**
    1810. 

  1810. 	 * IMSUM
    1811. 

  1811. 	 *
    1812. 

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

  1813. 	 *
    1814. 

  1814. 	 * @param	array of mixed		Data Series
    1815. 

  1815. 	 * @return	real
    1816. 

  1816. 	 */
    1817. 

  1817. 	public static function IMSUM() {
    1818. 

  1818. 		// Return value
    1819. 

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

  1820. 		$activeSuffix = '';
    1821. 

  1821. 

  1822. 		// Loop through the arguments
    1823. 

  1823. 		$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
    1824. 

  1824. 		foreach ($aArgs as $arg) {
    1825. 

  1825. 			$parsedComplex = self::_parseComplex($arg);
    1826. 

  1826. 			if (!is_array($parsedComplex)) {
    1827. 

  1827. 				return $parsedComplex;
    1828. 

  1828. 			}
    1829. 

  1829. 

  1830. 			if ($activeSuffix == '') {
    1831. 

  1831. 				$activeSuffix = $parsedComplex['suffix'];
    1832. 

  1832. 			} elseif (($parsedComplex['suffix'] != '') && ($activeSuffix != $parsedComplex['suffix'])) {
    1833. 

  1833. 				return PHPExcel_Calculation_Functions::VALUE();
    1834. 

  1834. 			}
    1835. 

  1835. 

  1836. 			$returnValue['real'] += $parsedComplex['real'];
    1837. 

  1837. 			$returnValue['imaginary'] += $parsedComplex['imaginary'];
    1838. 

  1838. 		}
    1839. 

  1839. 

  1840. 		if ($returnValue['imaginary'] == 0.0) { $activeSuffix = ''; }
    1841. 

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

  1842. 	}	//	function IMSUM()
    1843. 

  1843. 

  1844. 

  1845. 	/**
    1846. 

  1846. 	 * IMPRODUCT
    1847. 

  1847. 	 *
    1848. 

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

  1849. 	 *
    1850. 

  1850. 	 * @param	array of mixed		Data Series
    1851. 

  1851. 	 * @return	real
    1852. 

  1852. 	 */
    1853. 

  1853. 	public static function IMPRODUCT() {
    1854. 

  1854. 		// Return value
    1855. 

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

  1856. 		$activeSuffix = '';
    1857. 

  1857. 

  1858. 		// Loop through the arguments
    1859. 

  1859. 		$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
    1860. 

  1860. 		foreach ($aArgs as $arg) {
    1861. 

  1861. 			$parsedComplex = self::_parseComplex($arg);
    1862. 

  1862. 			if (!is_array($parsedComplex)) {
    1863. 

  1863. 				return $parsedComplex;
    1864. 

  1864. 			}
    1865. 

  1865. 			$workValue = $returnValue;
    1866. 

  1866. 			if (($parsedComplex['suffix'] != '') && ($activeSuffix == '')) {
    1867. 

  1867. 				$activeSuffix = $parsedComplex['suffix'];
    1868. 

  1868. 			} elseif (($parsedComplex['suffix'] != '') && ($activeSuffix != $parsedComplex['suffix'])) {
    1869. 

  1869. 				return PHPExcel_Calculation_Functions::NaN();
    1870. 

  1870. 			}
    1871. 

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

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

  1873. 		}
    1874. 

  1874. 

  1875. 		if ($returnValue['imaginary'] == 0.0) { $activeSuffix = ''; }
    1876. 

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

  1877. 	}	//	function IMPRODUCT()
    1878. 

  1878. 

  1879. 

  1880. 	/**
    1881. 

  1881. 	 * DELTA
    1882. 

  1882. 	 *
    1883. 

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

  1884. 	 *
    1885. 

  1885. 	 * @param	float		$a
    1886. 

  1886. 	 * @param	float		$b
    1887. 

  1887. 	 * @return	int
    1888. 

  1888. 	 */
    1889. 

  1889. 	public static function DELTA($a, $b=0) {
    1890. 

  1890. 		$a	= PHPExcel_Calculation_Functions::flattenSingleValue($a);
    1891. 

  1891. 		$b	= PHPExcel_Calculation_Functions::flattenSingleValue($b);
    1892. 

  1892. 

  1893. 		return (int) ($a == $b);
    1894. 

  1894. 	}	//	function DELTA()
    1895. 

  1895. 

  1896. 

  1897. 	/**
    1898. 

  1898. 	 * GESTEP
    1899. 

  1899. 	 *
    1900. 

  1900. 	 * Returns 1 if number = step; returns 0 (zero) otherwise
    1901. 

  1901. 	 *
    1902. 

  1902. 	 * @param	float		$number
    1903. 

  1903. 	 * @param	float		$step
    1904. 

  1904. 	 * @return	int
    1905. 

  1905. 	 */
    1906. 

  1906. 	public static function GESTEP($number, $step=0) {
    1907. 

  1907. 		$number	= PHPExcel_Calculation_Functions::flattenSingleValue($number);
    1908. 

  1908. 		$step	= PHPExcel_Calculation_Functions::flattenSingleValue($step);
    1909. 

  1909. 

  1910. 		return (int) ($number >= $step);
    1911. 

  1911. 	}	//	function GESTEP()
    1912. 

  1912. 

  1913. 

  1914. 	//
    1915. 

  1915. 	//	Private method to calculate the erf value
    1916. 

  1916. 	//
    1917. 

  1917. 	private static $_two_sqrtpi = 1.128379167095512574;
    1918. 

  1918. 

  1919. 	public static function _erfVal($x) {
    1920. 

  1920. 		if (abs($x) > 2.2) {
    1921. 

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

  1922. 		}
    1923. 

  1923. 		$sum = $term = $x;
    1924. 

  1924. 		$xsqr = ($x * $x);
    1925. 

  1925. 		$j = 1;
    1926. 

  1926. 		do {
    1927. 

  1927. 			$term *= $xsqr / $j;
    1928. 

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

  1929. 			++$j;
    1930. 

  1930. 			$term *= $xsqr / $j;
    1931. 

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

  1932. 			++$j;
    1933. 

  1933. 			if ($sum == 0.0) {
    1934. 

  1934. 				break;
    1935. 

  1935. 			}
    1936. 

  1936. 		} while (abs($term / $sum) > PRECISION);
    1937. 

  1937. 		return self::$_two_sqrtpi * $sum;
    1938. 

  1938. 	}	//	function _erfVal()
    1939. 

  1939. 

  1940. 

  1941. 	/**
    1942. 

  1942. 	 * ERF
    1943. 

  1943. 	 *
    1944. 

  1944. 	 * Returns the error function integrated between lower_limit and upper_limit
    1945. 

  1945. 	 *
    1946. 

  1946. 	 * @param	float		$lower	lower bound for integrating ERF
    1947. 

  1947. 	 * @param	float		$upper	upper bound for integrating ERF.
    1948. 

  1948. 	 *								If omitted, ERF integrates between zero and lower_limit
    1949. 

  1949. 	 * @return	int
    1950. 

  1950. 	 */
    1951. 

  1951. 	public static function ERF($lower, $upper = null) {
    1952. 

  1952. 		$lower	= PHPExcel_Calculation_Functions::flattenSingleValue($lower);
    1953. 

  1953. 		$upper	= PHPExcel_Calculation_Functions::flattenSingleValue($upper);
    1954. 

  1954. 

  1955. 		if (is_numeric($lower)) {
    1956. 

  1956. 			if ($lower < 0) {
    1957. 

  1957. 				return PHPExcel_Calculation_Functions::NaN();
    1958. 

  1958. 			}
    1959. 

  1959. 			if (is_null($upper)) {
    1960. 

  1960. 				return self::_erfVal($lower);
    1961. 

  1961. 			}
    1962. 

  1962. 			if (is_numeric($upper)) {
    1963. 

  1963. 				if ($upper < 0) {
    1964. 

  1964. 					return PHPExcel_Calculation_Functions::NaN();
    1965. 

  1965. 				}
    1966. 

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

  1967. 			}
    1968. 

  1968. 		}
    1969. 

  1969. 		return PHPExcel_Calculation_Functions::VALUE();
    1970. 

  1970. 	}	//	function ERF()
    1971. 

  1971. 

  1972. 

  1973. 	//
    1974. 

  1974. 	//	Private method to calculate the erfc value
    1975. 

  1975. 	//
    1976. 

  1976. 	private static $_one_sqrtpi = 0.564189583547756287;
    1977. 

  1977. 

  1978. 	private static function _erfcVal($x) {
    1979. 

  1979. 		if (abs($x) < 2.2) {
    1980. 

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

  1981. 		}
    1982. 

  1982. 		if ($x < 0) {
    1983. 

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

  1984. 		}
    1985. 

  1985. 		$a = $n = 1;
    1986. 

  1986. 		$b = $c = $x;
    1987. 

  1987. 		$d = ($x * $x) + 0.5;
    1988. 

  1988. 		$q1 = $q2 = $b / $d;
    1989. 

  1989. 		$t = 0;
    1990. 

  1990. 		do {
    1991. 

  1991. 			$t = $a * $n + $b * $x;
    1992. 

  1992. 			$a = $b;
    1993. 

  1993. 			$b = $t;
    1994. 

  1994. 			$t = $c * $n + $d * $x;
    1995. 

  1995. 			$c = $d;
    1996. 

  1996. 			$d = $t;
    1997. 

  1997. 			$n += 0.5;
    1998. 

  1998. 			$q1 = $q2;
    1999. 

  1999. 			$q2 = $b / $d;
    2000. 

  2000. 		} while ((abs($q1 - $q2) / $q2) > PRECISION);
    2001. 

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

  2002. 	}	//	function _erfcVal()
    2003. 

  2003. 

  2004. 

  2005. 	/**
    2006. 

  2006. 	 * ERFC
    2007. 

  2007. 	 *
    2008. 

  2008. 	 * Returns the complementary ERF function integrated between x and infinity
    2009. 

  2009. 	 *
    2010. 

  2010. 	 * @param	float		$x		The lower bound for integrating ERF
    2011. 

  2011. 	 * @return	int
    2012. 

  2012. 	 */
    2013. 

  2013. 	public static function ERFC($x) {
    2014. 

  2014. 		$x	= PHPExcel_Calculation_Functions::flattenSingleValue($x);
    2015. 

  2015. 

  2016. 		if (is_numeric($x)) {
    2017. 

  2017. 			if ($x < 0) {
    2018. 

  2018. 				return PHPExcel_Calculation_Functions::NaN();
    2019. 

  2019. 			}
    2020. 

  2020. 			return self::_erfcVal($x);
    2021. 

  2021. 		}
    2022. 

  2022. 		return PHPExcel_Calculation_Functions::VALUE();
    2023. 

  2023. 	}	//	function ERFC()
    2024. 

  2024. 

  2025. 

  2026. 	/**
    2027. 

  2027. 	 * getConversionGroups
    2028. 

  2028. 	 *
    2029. 

  2029. 	 * @return	array
    2030. 

  2030. 	 */
    2031. 

  2031. 	public static function getConversionGroups() {
    2032. 

  2032. 		$conversionGroups = array();
    2033. 

  2033. 		foreach(self::$_conversionUnits as $conversionUnit) {
    2034. 

  2034. 			$conversionGroups[] = $conversionUnit['Group'];
    2035. 

  2035. 		}
    2036. 

  2036. 		return array_merge(array_unique($conversionGroups));
    2037. 

  2037. 	}	//	function getConversionGroups()
    2038. 

  2038. 

  2039. 

  2040. 	/**
    2041. 

  2041. 	 * getConversionGroupUnits
    2042. 

  2042. 	 *
    2043. 

  2043. 	 * @return	array
    2044. 

  2044. 	 */
    2045. 

  2045. 	public static function getConversionGroupUnits($group = NULL) {
    2046. 

  2046. 		$conversionGroups = array();
    2047. 

  2047. 		foreach(self::$_conversionUnits as $conversionUnit => $conversionGroup) {
    2048. 

  2048. 			if ((is_null($group)) || ($conversionGroup['Group'] == $group)) {
    2049. 

  2049. 				$conversionGroups[$conversionGroup['Group']][] = $conversionUnit;
    2050. 

  2050. 			}
    2051. 

  2051. 		}
    2052. 

  2052. 		return $conversionGroups;
    2053. 

  2053. 	}	//	function getConversionGroupUnits()
    2054. 

  2054. 

  2055. 

  2056. 	/**
    2057. 

  2057. 	 * getConversionGroupUnitDetails
    2058. 

  2058. 	 *
    2059. 

  2059. 	 * @return	array
    2060. 

  2060. 	 */
    2061. 

  2061. 	public static function getConversionGroupUnitDetails($group = NULL) {
    2062. 

  2062. 		$conversionGroups = array();
    2063. 

  2063. 		foreach(self::$_conversionUnits as $conversionUnit => $conversionGroup) {
    2064. 

  2064. 			if ((is_null($group)) || ($conversionGroup['Group'] == $group)) {
    2065. 

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

  2066. 																		'description'	=> $conversionGroup['Unit Name']
    2067. 

  2067. 																	  );
    2068. 

  2068. 			}
    2069. 

  2069. 		}
    2070. 

  2070. 		return $conversionGroups;
    2071. 

  2071. 	}	//	function getConversionGroupUnitDetails()
    2072. 

  2072. 

  2073. 

  2074. 	/**
    2075. 

  2075. 	 * getConversionGroups
    2076. 

  2076. 	 *
    2077. 

  2077. 	 * @return	array
    2078. 

  2078. 	 */
    2079. 

  2079. 	public static function getConversionMultipliers() {
    2080. 

  2080. 		return self::$_conversionMultipliers;
    2081. 

  2081. 	}	//	function getConversionGroups()
    2082. 

  2082. 

  2083. 

  2084. 	/**
    2085. 

  2085. 	 * CONVERTUOM
    2086. 

  2086. 	 *
    2087. 

  2087. 	 * @param	float		$value
    2088. 

  2088. 	 * @param	string		$fromUOM
    2089. 

  2089. 	 * @param	string		$toUOM
    2090. 

  2090. 	 * @return	float
    2091. 

  2091. 	 */
    2092. 

  2092. 	public static function CONVERTUOM($value, $fromUOM, $toUOM) {
    2093. 

  2093. 		$value		= PHPExcel_Calculation_Functions::flattenSingleValue($value);
    2094. 

  2094. 		$fromUOM	= PHPExcel_Calculation_Functions::flattenSingleValue($fromUOM);
    2095. 

  2095. 		$toUOM		= PHPExcel_Calculation_Functions::flattenSingleValue($toUOM);
    2096. 

  2096. 

  2097. 		if (!is_numeric($value)) {
    2098. 

  2098. 			return PHPExcel_Calculation_Functions::VALUE();
    2099. 

  2099. 		}
    2100. 

  2100. 		$fromMultiplier = 1;
    2101. 

  2101. 		if (isset(self::$_conversionUnits[$fromUOM])) {
    2102. 

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

  2103. 		} else {
    2104. 

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

  2105. 			$fromUOM = substr($fromUOM,1);
    2106. 

  2106. 			if (isset(self::$_conversionMultipliers[$fromMultiplier])) {
    2107. 

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

  2108. 			} else {
    2109. 

  2109. 				return PHPExcel_Calculation_Functions::NA();
    2110. 

  2110. 			}
    2111. 

  2111. 			if ((isset(self::$_conversionUnits[$fromUOM])) && (self::$_conversionUnits[$fromUOM]['AllowPrefix'])) {
    2112. 

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

  2113. 			} else {
    2114. 

  2114. 				return PHPExcel_Calculation_Functions::NA();
    2115. 

  2115. 			}
    2116. 

  2116. 		}
    2117. 

  2117. 		$value *= $fromMultiplier;
    2118. 

  2118. 

  2119. 		$toMultiplier = 1;
    2120. 

  2120. 		if (isset(self::$_conversionUnits[$toUOM])) {
    2121. 

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

  2122. 		} else {
    2123. 

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

  2124. 			$toUOM = substr($toUOM,1);
    2125. 

  2125. 			if (isset(self::$_conversionMultipliers[$toMultiplier])) {
    2126. 

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

  2127. 			} else {
    2128. 

  2128. 				return PHPExcel_Calculation_Functions::NA();
    2129. 

  2129. 			}
    2130. 

  2130. 			if ((isset(self::$_conversionUnits[$toUOM])) && (self::$_conversionUnits[$toUOM]['AllowPrefix'])) {
    2131. 

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

  2132. 			} else {
    2133. 

  2133. 				return PHPExcel_Calculation_Functions::NA();
    2134. 

  2134. 			}
    2135. 

  2135. 		}
    2136. 

  2136. 		if ($unitGroup1 != $unitGroup2) {
    2137. 

  2137. 			return PHPExcel_Calculation_Functions::NA();
    2138. 

  2138. 		}
    2139. 

  2139. 

  2140. 		if ($fromUOM == $toUOM) {
    2141. 

  2141. 			return 1.0;
    2142. 

  2142. 		} elseif ($unitGroup1 == 'Temperature') {
    2143. 

  2143. 			if (($fromUOM == 'F') || ($fromUOM == 'fah')) {
    2144. 

  2144. 				if (($toUOM == 'F') || ($toUOM == 'fah')) {
    2145. 

  2145. 					return 1.0;
    2146. 

  2146. 				} else {
    2147. 

  2147. 					$value = (($value - 32) / 1.8);
    2148. 

  2148. 					if (($toUOM == 'K') || ($toUOM == 'kel')) {
    2149. 

  2149. 						$value += 273.15;
    2150. 

  2150. 					}
    2151. 

  2151. 					return $value;
    2152. 

  2152. 				}
    2153. 

  2153. 			} elseif ((($fromUOM == 'K') || ($fromUOM == 'kel')) &&
    2154. 

  2154. 					  (($toUOM == 'K') || ($toUOM == 'kel'))) {
    2155. 

  2155. 						return 1.0;
    2156. 

  2156. 			} elseif ((($fromUOM == 'C') || ($fromUOM == 'cel')) &&
    2157. 

  2157. 					  (($toUOM == 'C') || ($toUOM == 'cel'))) {
    2158. 

  2158. 					return 1.0;
    2159. 

  2159. 			}
    2160. 

  2160. 			if (($toUOM == 'F') || ($toUOM == 'fah')) {
    2161. 

  2161. 				if (($fromUOM == 'K') || ($fromUOM == 'kel')) {
    2162. 

  2162. 					$value -= 273.15;
    2163. 

  2163. 				}
    2164. 

  2164. 				return ($value * 1.8) + 32;
    2165. 

  2165. 			}
    2166. 

  2166. 			if (($toUOM == 'C') || ($toUOM == 'cel')) {
    2167. 

  2167. 				return $value - 273.15;
    2168. 

  2168. 			}
    2169. 

  2169. 			return $value + 273.15;
    2170. 

  2170. 		}
    2171. 

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

  2172. 	}	//	function CONVERTUOM()
    2173. 

  2173. 

  2174. }	//	class PHPExcel_Calculation_Engineering
    2175. 

  2175.