File Source for Engineering.php

PHPExcel_Calculation

# Source for file Engineering.php

Documentation is available at Engineering.php

1. <?php
2. /**
3. * PHPExcel
4. *
5. * Copyright (c) 2006 - 2011 PHPExcel
6. *
7. * This library is free software; you can redistribute it and/or
8. * modify it under the terms of the GNU Lesser General Public
9. * License as published by the Free Software Foundation; either
10. * version 2.1 of the License, or (at your option) any later version.
11. *
12. * This library is distributed in the hope that it will be useful,
13. * but WITHOUT ANY WARRANTY; without even the implied warranty of
14. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15. * Lesser General Public License for more details.
16. *
17. * You should have received a copy of the GNU Lesser General Public
18. * License along with this library; if not, write to the Free Software
19. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20. *
21. * @category PHPExcel
22. * @package PHPExcel_Calculation
23. * @copyright Copyright (c) 2006 - 2011 PHPExcel (http://www.codeplex.com/PHPExcel)
24. * @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
25. * @version 1.7.6, 2011-02-27
26. */
29. /** PHPExcel root directory */
30. if (! defined('PHPEXCEL_ROOT')) {
31. /**
32. * @ignore
33. */
34. define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../');
35. require(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
36. }
39. /** EULER */
40. define('EULER', 2.71828182845904523536);
43. /**
44. * PHPExcel_Calculation_Engineering
45. *
46. * @category PHPExcel
47. * @package PHPExcel_Calculation
48. * @copyright Copyright (c) 2006 - 2011 PHPExcel (http://www.codeplex.com/PHPExcel)
49. */
50. class PHPExcel_Calculation_Engineering {
52. private static $_conversionUnits = array( 'g' => array( 'Group' => 'Mass', 'Unit Name' => 'Gram', 'AllowPrefix' => True ),
53. 'sg' => array( 'Group' => 'Mass', 'Unit Name' => 'Slug', 'AllowPrefix' => False ),
54. 'lbm' => array( 'Group' => 'Mass', 'Unit Name' => 'Pound mass (avoirdupois)', 'AllowPrefix' => False ),
55. 'u' => array( 'Group' => 'Mass', 'Unit Name' => 'U (atomic mass unit)', 'AllowPrefix' => True ),
56. 'ozm' => array( 'Group' => 'Mass', 'Unit Name' => 'Ounce mass (avoirdupois)', 'AllowPrefix' => False ),
57. 'm' => array( 'Group' => 'Distance', 'Unit Name' => 'Meter', 'AllowPrefix' => True ),
58. 'mi' => array( 'Group' => 'Distance', 'Unit Name' => 'Statute mile', 'AllowPrefix' => False ),
59. 'Nmi' => array( 'Group' => 'Distance', 'Unit Name' => 'Nautical mile', 'AllowPrefix' => False ),
60. 'in' => array( 'Group' => 'Distance', 'Unit Name' => 'Inch', 'AllowPrefix' => False ),
61. 'ft' => array( 'Group' => 'Distance', 'Unit Name' => 'Foot', 'AllowPrefix' => False ),
62. 'yd' => array( 'Group' => 'Distance', 'Unit Name' => 'Yard', 'AllowPrefix' => False ),
63. 'ang' => array( 'Group' => 'Distance', 'Unit Name' => 'Angstrom', 'AllowPrefix' => True ),
64. 'Pica' => array( 'Group' => 'Distance', 'Unit Name' => 'Pica (1/72 in)', 'AllowPrefix' => False ),
65. 'yr' => array( 'Group' => 'Time', 'Unit Name' => 'Year', 'AllowPrefix' => False ),
66. 'day' => array( 'Group' => 'Time', 'Unit Name' => 'Day', 'AllowPrefix' => False ),
67. 'hr' => array( 'Group' => 'Time', 'Unit Name' => 'Hour', 'AllowPrefix' => False ),
68. 'mn' => array( 'Group' => 'Time', 'Unit Name' => 'Minute', 'AllowPrefix' => False ),
69. 'sec' => array( 'Group' => 'Time', 'Unit Name' => 'Second', 'AllowPrefix' => True ),
70. 'Pa' => array( 'Group' => 'Pressure', 'Unit Name' => 'Pascal', 'AllowPrefix' => True ),
71. 'p' => array( 'Group' => 'Pressure', 'Unit Name' => 'Pascal', 'AllowPrefix' => True ),
72. 'atm' => array( 'Group' => 'Pressure', 'Unit Name' => 'Atmosphere', 'AllowPrefix' => True ),
73. 'at' => array( 'Group' => 'Pressure', 'Unit Name' => 'Atmosphere', 'AllowPrefix' => True ),
74. 'mmHg' => array( 'Group' => 'Pressure', 'Unit Name' => 'mm of Mercury', 'AllowPrefix' => True ),
75. 'N' => array( 'Group' => 'Force', 'Unit Name' => 'Newton', 'AllowPrefix' => True ),
76. 'dyn' => array( 'Group' => 'Force', 'Unit Name' => 'Dyne', 'AllowPrefix' => True ),
77. 'dy' => array( 'Group' => 'Force', 'Unit Name' => 'Dyne', 'AllowPrefix' => True ),
78. 'lbf' => array( 'Group' => 'Force', 'Unit Name' => 'Pound force', 'AllowPrefix' => False ),
79. 'J' => array( 'Group' => 'Energy', 'Unit Name' => 'Joule', 'AllowPrefix' => True ),
80. 'e' => array( 'Group' => 'Energy', 'Unit Name' => 'Erg', 'AllowPrefix' => True ),
81. 'c' => array( 'Group' => 'Energy', 'Unit Name' => 'Thermodynamic calorie', 'AllowPrefix' => True ),
82. 'cal' => array( 'Group' => 'Energy', 'Unit Name' => 'IT calorie', 'AllowPrefix' => True ),
83. 'eV' => array( 'Group' => 'Energy', 'Unit Name' => 'Electron volt', 'AllowPrefix' => True ),
84. 'ev' => array( 'Group' => 'Energy', 'Unit Name' => 'Electron volt', 'AllowPrefix' => True ),
85. 'HPh' => array( 'Group' => 'Energy', 'Unit Name' => 'Horsepower-hour', 'AllowPrefix' => False ),
86. 'hh' => array( 'Group' => 'Energy', 'Unit Name' => 'Horsepower-hour', 'AllowPrefix' => False ),
87. 'Wh' => array( 'Group' => 'Energy', 'Unit Name' => 'Watt-hour', 'AllowPrefix' => True ),
88. 'wh' => array( 'Group' => 'Energy', 'Unit Name' => 'Watt-hour', 'AllowPrefix' => True ),
89. 'flb' => array( 'Group' => 'Energy', 'Unit Name' => 'Foot-pound', 'AllowPrefix' => False ),
90. 'BTU' => array( 'Group' => 'Energy', 'Unit Name' => 'BTU', 'AllowPrefix' => False ),
91. 'btu' => array( 'Group' => 'Energy', 'Unit Name' => 'BTU', 'AllowPrefix' => False ),
92. 'HP' => array( 'Group' => 'Power', 'Unit Name' => 'Horsepower', 'AllowPrefix' => False ),
93. 'h' => array( 'Group' => 'Power', 'Unit Name' => 'Horsepower', 'AllowPrefix' => False ),
94. 'W' => array( 'Group' => 'Power', 'Unit Name' => 'Watt', 'AllowPrefix' => True ),
95. 'w' => array( 'Group' => 'Power', 'Unit Name' => 'Watt', 'AllowPrefix' => True ),
96. 'T' => array( 'Group' => 'Magnetism', 'Unit Name' => 'Tesla', 'AllowPrefix' => True ),
97. 'ga' => array( 'Group' => 'Magnetism', 'Unit Name' => 'Gauss', 'AllowPrefix' => True ),
98. 'C' => array( 'Group' => 'Temperature', 'Unit Name' => 'Celsius', 'AllowPrefix' => False ),
99. 'cel' => array( 'Group' => 'Temperature', 'Unit Name' => 'Celsius', 'AllowPrefix' => False ),
100. 'F' => array( 'Group' => 'Temperature', 'Unit Name' => 'Fahrenheit', 'AllowPrefix' => False ),
101. 'fah' => array( 'Group' => 'Temperature', 'Unit Name' => 'Fahrenheit', 'AllowPrefix' => False ),
102. 'K' => array( 'Group' => 'Temperature', 'Unit Name' => 'Kelvin', 'AllowPrefix' => False ),
103. 'kel' => array( 'Group' => 'Temperature', 'Unit Name' => 'Kelvin', 'AllowPrefix' => False ),
104. 'tsp' => array( 'Group' => 'Liquid', 'Unit Name' => 'Teaspoon', 'AllowPrefix' => False ),
105. 'tbs' => array( 'Group' => 'Liquid', 'Unit Name' => 'Tablespoon', 'AllowPrefix' => False ),
106. 'oz' => array( 'Group' => 'Liquid', 'Unit Name' => 'Fluid Ounce', 'AllowPrefix' => False ),
107. 'cup' => array( 'Group' => 'Liquid', 'Unit Name' => 'Cup', 'AllowPrefix' => False ),
108. 'pt' => array( 'Group' => 'Liquid', 'Unit Name' => 'U.S. Pint', 'AllowPrefix' => False ),
109. 'us_pt' => array( 'Group' => 'Liquid', 'Unit Name' => 'U.S. Pint', 'AllowPrefix' => False ),
110. 'uk_pt' => array( 'Group' => 'Liquid', 'Unit Name' => 'U.K. Pint', 'AllowPrefix' => False ),
111. 'qt' => array( 'Group' => 'Liquid', 'Unit Name' => 'Quart', 'AllowPrefix' => False ),
112. 'gal' => array( 'Group' => 'Liquid', 'Unit Name' => 'Gallon', 'AllowPrefix' => False ),
113. 'l' => array( 'Group' => 'Liquid', 'Unit Name' => 'Litre', 'AllowPrefix' => True ),
114. 'lt' => array( 'Group' => 'Liquid', 'Unit Name' => 'Litre', 'AllowPrefix' => True )
115. );
117. private static $_conversionMultipliers = array( 'Y' => array( 'multiplier' => 1E24, 'name' => 'yotta' ),
118. 'Z' => array( 'multiplier' => 1E21, 'name' => 'zetta' ),
119. 'E' => array( 'multiplier' => 1E18, 'name' => 'exa' ),
120. 'P' => array( 'multiplier' => 1E15, 'name' => 'peta' ),
121. 'T' => array( 'multiplier' => 1E12, 'name' => 'tera' ),
122. 'G' => array( 'multiplier' => 1E9, 'name' => 'giga' ),
123. 'M' => array( 'multiplier' => 1E6, 'name' => 'mega' ),
124. 'k' => array( 'multiplier' => 1E3, 'name' => 'kilo' ),
125. 'h' => array( 'multiplier' => 1E2, 'name' => 'hecto' ),
126. 'e' => array( 'multiplier' => 1E1, 'name' => 'deka' ),
127. 'd' => array( 'multiplier' => 1E-1, 'name' => 'deci' ),
128. 'c' => array( 'multiplier' => 1E-2, 'name' => 'centi' ),
129. 'm' => array( 'multiplier' => 1E-3, 'name' => 'milli' ),
130. 'u' => array( 'multiplier' => 1E-6, 'name' => 'micro' ),
131. 'n' => array( 'multiplier' => 1E-9, 'name' => 'nano' ),
132. 'p' => array( 'multiplier' => 1E-12, 'name' => 'pico' ),
133. 'f' => array( 'multiplier' => 1E-15, 'name' => 'femto' ),
134. 'a' => array( 'multiplier' => 1E-18, 'name' => 'atto' ),
135. 'z' => array( 'multiplier' => 1E-21, 'name' => 'zepto' ),
136. 'y' => array( 'multiplier' => 1E-24, 'name' => 'yocto' )
137. );
139. private static $_unitConversions = array( 'Mass' => array( 'g' => array( 'g' => 1.0,
140. 'sg' => 6.85220500053478E-05,
141. 'lbm' => 2.20462291469134E-03,
142. 'u' => 6.02217000000000E+23,
143. 'ozm' => 3.52739718003627E-02
144. ),
145. 'sg' => array( 'g' => 1.45938424189287E+04,
146. 'sg' => 1.0,
147. 'lbm' => 3.21739194101647E+01,
148. 'u' => 8.78866000000000E+27,
149. 'ozm' => 5.14782785944229E+02
150. ),
151. 'lbm' => array( 'g' => 4.5359230974881148E+02,
152. 'sg' => 3.10810749306493E-02,
153. 'lbm' => 1.0,
154. 'u' => 2.73161000000000E+26,
155. 'ozm' => 1.60000023429410E+01
156. ),
157. 'u' => array( 'g' => 1.66053100460465E-24,
158. 'sg' => 1.13782988532950E-28,
159. 'lbm' => 3.66084470330684E-27,
160. 'u' => 1.0,
161. 'ozm' => 5.85735238300524E-26
162. ),
163. 'ozm' => array( 'g' => 2.83495152079732E+01,
164. 'sg' => 1.94256689870811E-03,
165. 'lbm' => 6.24999908478882E-02,
166. 'u' => 1.70725600000000E+25,
167. 'ozm' => 1.0
168. )
169. ),
170. 'Distance' => array( 'm' => array( 'm' => 1.0,
171. 'mi' => 6.21371192237334E-04,
172. 'Nmi' => 5.39956803455724E-04,
173. 'in' => 3.93700787401575E+01,
174. 'ft' => 3.28083989501312E+00,
175. 'yd' => 1.09361329797891E+00,
176. 'ang' => 1.00000000000000E+10,
177. 'Pica' => 2.83464566929116E+03
178. ),
179. 'mi' => array( 'm' => 1.60934400000000E+03,
180. 'mi' => 1.0,
181. 'Nmi' => 8.68976241900648E-01,
182. 'in' => 6.33600000000000E+04,
183. 'ft' => 5.28000000000000E+03,
184. 'yd' => 1.76000000000000E+03,
185. 'ang' => 1.60934400000000E+13,
186. 'Pica' => 4.56191999999971E+06
187. ),
188. 'Nmi' => array( 'm' => 1.85200000000000E+03,
189. 'mi' => 1.15077944802354E+00,
190. 'Nmi' => 1.0,
191. 'in' => 7.29133858267717E+04,
192. 'ft' => 6.07611548556430E+03,
193. 'yd' => 2.02537182785694E+03,
194. 'ang' => 1.85200000000000E+13,
195. 'Pica' => 5.24976377952723E+06
196. ),
197. 'in' => array( 'm' => 2.54000000000000E-02,
198. 'mi' => 1.57828282828283E-05,
199. 'Nmi' => 1.37149028077754E-05,
200. 'in' => 1.0,
201. 'ft' => 8.33333333333333E-02,
202. 'yd' => 2.77777777686643E-02,
203. 'ang' => 2.54000000000000E+08,
204. 'Pica' => 7.19999999999955E+01
205. ),
206. 'ft' => array( 'm' => 3.04800000000000E-01,
207. 'mi' => 1.89393939393939E-04,
208. 'Nmi' => 1.64578833693305E-04,
209. 'in' => 1.20000000000000E+01,
210. 'ft' => 1.0,
211. 'yd' => 3.33333333223972E-01,
212. 'ang' => 3.04800000000000E+09,
213. 'Pica' => 8.63999999999946E+02
214. ),
215. 'yd' => array( 'm' => 9.14400000300000E-01,
216. 'mi' => 5.68181818368230E-04,
217. 'Nmi' => 4.93736501241901E-04,
218. 'in' => 3.60000000118110E+01,
219. 'ft' => 3.00000000000000E+00,
220. 'yd' => 1.0,
221. 'ang' => 9.14400000300000E+09,
222. 'Pica' => 2.59200000085023E+03
223. ),
224. 'ang' => array( 'm' => 1.00000000000000E-10,
225. 'mi' => 6.21371192237334E-14,
226. 'Nmi' => 5.39956803455724E-14,
227. 'in' => 3.93700787401575E-09,
228. 'ft' => 3.28083989501312E-10,
229. 'yd' => 1.09361329797891E-10,
230. 'ang' => 1.0,
231. 'Pica' => 2.83464566929116E-07
232. ),
233. 'Pica' => array( 'm' => 3.52777777777800E-04,
234. 'mi' => 2.19205948372629E-07,
235. 'Nmi' => 1.90484761219114E-07,
236. 'in' => 1.38888888888898E-02,
237. 'ft' => 1.15740740740748E-03,
238. 'yd' => 3.85802469009251E-04,
239. 'ang' => 3.52777777777800E+06,
240. 'Pica' => 1.0
241. )
242. ),
243. 'Time' => array( 'yr' => array( 'yr' => 1.0,
244. 'day' => 365.25,
245. 'hr' => 8766.0,
246. 'mn' => 525960.0,
247. 'sec' => 31557600.0
248. ),
249. 'day' => array( 'yr' => 2.73785078713210E-03,
250. 'day' => 1.0,
251. 'hr' => 24.0,
252. 'mn' => 1440.0,
253. 'sec' => 86400.0
254. ),
255. 'hr' => array( 'yr' => 1.14077116130504E-04,
256. 'day' => 4.16666666666667E-02,
257. 'hr' => 1.0,
258. 'mn' => 60.0,
259. 'sec' => 3600.0
260. ),
261. 'mn' => array( 'yr' => 1.90128526884174E-06,
262. 'day' => 6.94444444444444E-04,
263. 'hr' => 1.66666666666667E-02,
264. 'mn' => 1.0,
265. 'sec' => 60.0
266. ),
267. 'sec' => array( 'yr' => 3.16880878140289E-08,
268. 'day' => 1.15740740740741E-05,
269. 'hr' => 2.77777777777778E-04,
270. 'mn' => 1.66666666666667E-02,
271. 'sec' => 1.0
272. )
273. ),
274. 'Pressure' => array( 'Pa' => array( 'Pa' => 1.0,
275. 'p' => 1.0,
276. 'atm' => 9.86923299998193E-06,
277. 'at' => 9.86923299998193E-06,
278. 'mmHg' => 7.50061707998627E-03
279. ),
280. 'p' => array( 'Pa' => 1.0,
281. 'p' => 1.0,
282. 'atm' => 9.86923299998193E-06,
283. 'at' => 9.86923299998193E-06,
284. 'mmHg' => 7.50061707998627E-03
285. ),
286. 'atm' => array( 'Pa' => 1.01324996583000E+05,
287. 'p' => 1.01324996583000E+05,
288. 'atm' => 1.0,
289. 'at' => 1.0,
290. 'mmHg' => 760.0
291. ),
292. 'at' => array( 'Pa' => 1.01324996583000E+05,
293. 'p' => 1.01324996583000E+05,
294. 'atm' => 1.0,
295. 'at' => 1.0,
296. 'mmHg' => 760.0
297. ),
298. 'mmHg' => array( 'Pa' => 1.33322363925000E+02,
299. 'p' => 1.33322363925000E+02,
300. 'atm' => 1.31578947368421E-03,
301. 'at' => 1.31578947368421E-03,
302. 'mmHg' => 1.0
303. )
304. ),
305. 'Force' => array( 'N' => array( 'N' => 1.0,
306. 'dyn' => 1.0E+5,
307. 'dy' => 1.0E+5,
308. 'lbf' => 2.24808923655339E-01
309. ),
310. 'dyn' => array( 'N' => 1.0E-5,
311. 'dyn' => 1.0,
312. 'dy' => 1.0,
313. 'lbf' => 2.24808923655339E-06
314. ),
315. 'dy' => array( 'N' => 1.0E-5,
316. 'dyn' => 1.0,
317. 'dy' => 1.0,
318. 'lbf' => 2.24808923655339E-06
319. ),
320. 'lbf' => array( 'N' => 4.448222,
321. 'dyn' => 4.448222E+5,
322. 'dy' => 4.448222E+5,
323. 'lbf' => 1.0
324. )
325. ),
326. 'Energy' => array( 'J' => array( 'J' => 1.0,
327. 'e' => 9.99999519343231E+06,
328. 'c' => 2.39006249473467E-01,
329. 'cal' => 2.38846190642017E-01,
330. 'eV' => 6.24145700000000E+18,
331. 'ev' => 6.24145700000000E+18,
332. 'HPh' => 3.72506430801000E-07,
333. 'hh' => 3.72506430801000E-07,
334. 'Wh' => 2.77777916238711E-04,
335. 'wh' => 2.77777916238711E-04,
336. 'flb' => 2.37304222192651E+01,
337. 'BTU' => 9.47815067349015E-04,
338. 'btu' => 9.47815067349015E-04
339. ),
340. 'e' => array( 'J' => 1.00000048065700E-07,
341. 'e' => 1.0,
342. 'c' => 2.39006364353494E-08,
343. 'cal' => 2.38846305445111E-08,
344. 'eV' => 6.24146000000000E+11,
345. 'ev' => 6.24146000000000E+11,
346. 'HPh' => 3.72506609848824E-14,
347. 'hh' => 3.72506609848824E-14,
348. 'Wh' => 2.77778049754611E-11,
349. 'wh' => 2.77778049754611E-11,
350. 'flb' => 2.37304336254586E-06,
351. 'BTU' => 9.47815522922962E-11,
352. 'btu' => 9.47815522922962E-11
353. ),
354. 'c' => array( 'J' => 4.18399101363672E+00,
355. 'e' => 4.18398900257312E+07,
356. 'c' => 1.0,
357. 'cal' => 9.99330315287563E-01,
358. 'eV' => 2.61142000000000E+19,
359. 'ev' => 2.61142000000000E+19,
360. 'HPh' => 1.55856355899327E-06,
361. 'hh' => 1.55856355899327E-06,
362. 'Wh' => 1.16222030532950E-03,
363. 'wh' => 1.16222030532950E-03,
364. 'flb' => 9.92878733152102E+01,
365. 'BTU' => 3.96564972437776E-03,
366. 'btu' => 3.96564972437776E-03
367. ),
368. 'cal' => array( 'J' => 4.18679484613929E+00,
369. 'e' => 4.18679283372801E+07,
370. 'c' => 1.00067013349059E+00,
371. 'cal' => 1.0,
372. 'eV' => 2.61317000000000E+19,
373. 'ev' => 2.61317000000000E+19,
374. 'HPh' => 1.55960800463137E-06,
375. 'hh' => 1.55960800463137E-06,
376. 'Wh' => 1.16299914807955E-03,
377. 'wh' => 1.16299914807955E-03,
378. 'flb' => 9.93544094443283E+01,
379. 'BTU' => 3.96830723907002E-03,
380. 'btu' => 3.96830723907002E-03
381. ),
382. 'eV' => array( 'J' => 1.60219000146921E-19,
383. 'e' => 1.60218923136574E-12,
384. 'c' => 3.82933423195043E-20,
385. 'cal' => 3.82676978535648E-20,
386. 'eV' => 1.0,
387. 'ev' => 1.0,
388. 'HPh' => 5.96826078912344E-26,
389. 'hh' => 5.96826078912344E-26,
390. 'Wh' => 4.45053000026614E-23,
391. 'wh' => 4.45053000026614E-23,
392. 'flb' => 3.80206452103492E-18,
393. 'BTU' => 1.51857982414846E-22,
394. 'btu' => 1.51857982414846E-22
395. ),
396. 'ev' => array( 'J' => 1.60219000146921E-19,
397. 'e' => 1.60218923136574E-12,
398. 'c' => 3.82933423195043E-20,
399. 'cal' => 3.82676978535648E-20,
400. 'eV' => 1.0,
401. 'ev' => 1.0,
402. 'HPh' => 5.96826078912344E-26,
403. 'hh' => 5.96826078912344E-26,
404. 'Wh' => 4.45053000026614E-23,
405. 'wh' => 4.45053000026614E-23,
406. 'flb' => 3.80206452103492E-18,
407. 'BTU' => 1.51857982414846E-22,
408. 'btu' => 1.51857982414846E-22
409. ),
410. 'HPh' => array( 'J' => 2.68451741316170E+06,
411. 'e' => 2.68451612283024E+13,
412. 'c' => 6.41616438565991E+05,
413. 'cal' => 6.41186757845835E+05,
414. 'eV' => 1.67553000000000E+25,
415. 'ev' => 1.67553000000000E+25,
416. 'HPh' => 1.0,
417. 'hh' => 1.0,
418. 'Wh' => 7.45699653134593E+02,
419. 'wh' => 7.45699653134593E+02,
420. 'flb' => 6.37047316692964E+07,
421. 'BTU' => 2.54442605275546E+03,
422. 'btu' => 2.54442605275546E+03
423. ),
424. 'hh' => array( 'J' => 2.68451741316170E+06,
425. 'e' => 2.68451612283024E+13,
426. 'c' => 6.41616438565991E+05,
427. 'cal' => 6.41186757845835E+05,
428. 'eV' => 1.67553000000000E+25,
429. 'ev' => 1.67553000000000E+25,
430. 'HPh' => 1.0,
431. 'hh' => 1.0,
432. 'Wh' => 7.45699653134593E+02,
433. 'wh' => 7.45699653134593E+02,
434. 'flb' => 6.37047316692964E+07,
435. 'BTU' => 2.54442605275546E+03,
436. 'btu' => 2.54442605275546E+03
437. ),
438. 'Wh' => array( 'J' => 3.59999820554720E+03,
439. 'e' => 3.59999647518369E+10,
440. 'c' => 8.60422069219046E+02,
441. 'cal' => 8.59845857713046E+02,
442. 'eV' => 2.24692340000000E+22,
443. 'ev' => 2.24692340000000E+22,
444. 'HPh' => 1.34102248243839E-03,
445. 'hh' => 1.34102248243839E-03,
446. 'Wh' => 1.0,
447. 'wh' => 1.0,
448. 'flb' => 8.54294774062316E+04,
449. 'BTU' => 3.41213254164705E+00,
450. 'btu' => 3.41213254164705E+00
451. ),
452. 'wh' => array( 'J' => 3.59999820554720E+03,
453. 'e' => 3.59999647518369E+10,
454. 'c' => 8.60422069219046E+02,
455. 'cal' => 8.59845857713046E+02,
456. 'eV' => 2.24692340000000E+22,
457. 'ev' => 2.24692340000000E+22,
458. 'HPh' => 1.34102248243839E-03,
459. 'hh' => 1.34102248243839E-03,
460. 'Wh' => 1.0,
461. 'wh' => 1.0,
462. 'flb' => 8.54294774062316E+04,
463. 'BTU' => 3.41213254164705E+00,
464. 'btu' => 3.41213254164705E+00
465. ),
466. 'flb' => array( 'J' => 4.21400003236424E-02,
467. 'e' => 4.21399800687660E+05,
468. 'c' => 1.00717234301644E-02,
469. 'cal' => 1.00649785509554E-02,
470. 'eV' => 2.63015000000000E+17,
471. 'ev' => 2.63015000000000E+17,
472. 'HPh' => 1.56974211145130E-08,
473. 'hh' => 1.56974211145130E-08,
474. 'Wh' => 1.17055614802000E-05,
475. 'wh' => 1.17055614802000E-05,
476. 'flb' => 1.0,
477. 'BTU' => 3.99409272448406E-05,
478. 'btu' => 3.99409272448406E-05
479. ),
480. 'BTU' => array( 'J' => 1.05505813786749E+03,
481. 'e' => 1.05505763074665E+10,
482. 'c' => 2.52165488508168E+02,
483. 'cal' => 2.51996617135510E+02,
484. 'eV' => 6.58510000000000E+21,
485. 'ev' => 6.58510000000000E+21,
486. 'HPh' => 3.93015941224568E-04,
487. 'hh' => 3.93015941224568E-04,
488. 'Wh' => 2.93071851047526E-01,
489. 'wh' => 2.93071851047526E-01,
490. 'flb' => 2.50369750774671E+04,
491. 'BTU' => 1.0,
492. 'btu' => 1.0,
493. ),
494. 'btu' => array( 'J' => 1.05505813786749E+03,
495. 'e' => 1.05505763074665E+10,
496. 'c' => 2.52165488508168E+02,
497. 'cal' => 2.51996617135510E+02,
498. 'eV' => 6.58510000000000E+21,
499. 'ev' => 6.58510000000000E+21,
500. 'HPh' => 3.93015941224568E-04,
501. 'hh' => 3.93015941224568E-04,
502. 'Wh' => 2.93071851047526E-01,
503. 'wh' => 2.93071851047526E-01,
504. 'flb' => 2.50369750774671E+04,
505. 'BTU' => 1.0,
506. 'btu' => 1.0,
507. )
508. ),
509. 'Power' => array( 'HP' => array( 'HP' => 1.0,
510. 'h' => 1.0,
511. 'W' => 7.45701000000000E+02,
512. 'w' => 7.45701000000000E+02
513. ),
514. 'h' => array( 'HP' => 1.0,
515. 'h' => 1.0,
516. 'W' => 7.45701000000000E+02,
517. 'w' => 7.45701000000000E+02
518. ),
519. 'W' => array( 'HP' => 1.34102006031908E-03,
520. 'h' => 1.34102006031908E-03,
521. 'W' => 1.0,
522. 'w' => 1.0
523. ),
524. 'w' => array( 'HP' => 1.34102006031908E-03,
525. 'h' => 1.34102006031908E-03,
526. 'W' => 1.0,
527. 'w' => 1.0
528. )
529. ),
530. 'Magnetism' => array( 'T' => array( 'T' => 1.0,
531. 'ga' => 10000.0
532. ),
533. 'ga' => array( 'T' => 0.0001,
534. 'ga' => 1.0
535. )
536. ),
537. 'Liquid' => array( 'tsp' => array( 'tsp' => 1.0,
538. 'tbs' => 3.33333333333333E-01,
539. 'oz' => 1.66666666666667E-01,
540. 'cup' => 2.08333333333333E-02,
541. 'pt' => 1.04166666666667E-02,
542. 'us_pt' => 1.04166666666667E-02,
543. 'uk_pt' => 8.67558516821960E-03,
544. 'qt' => 5.20833333333333E-03,
545. 'gal' => 1.30208333333333E-03,
546. 'l' => 4.92999408400710E-03,
547. 'lt' => 4.92999408400710E-03
548. ),
549. 'tbs' => array( 'tsp' => 3.00000000000000E+00,
550. 'tbs' => 1.0,
551. 'oz' => 5.00000000000000E-01,
552. 'cup' => 6.25000000000000E-02,
553. 'pt' => 3.12500000000000E-02,
554. 'us_pt' => 3.12500000000000E-02,
555. 'uk_pt' => 2.60267555046588E-02,
556. 'qt' => 1.56250000000000E-02,
557. 'gal' => 3.90625000000000E-03,
558. 'l' => 1.47899822520213E-02,
559. 'lt' => 1.47899822520213E-02
560. ),
561. 'oz' => array( 'tsp' => 6.00000000000000E+00,
562. 'tbs' => 2.00000000000000E+00,
563. 'oz' => 1.0,
564. 'cup' => 1.25000000000000E-01,
565. 'pt' => 6.25000000000000E-02,
566. 'us_pt' => 6.25000000000000E-02,
567. 'uk_pt' => 5.20535110093176E-02,
568. 'qt' => 3.12500000000000E-02,
569. 'gal' => 7.81250000000000E-03,
570. 'l' => 2.95799645040426E-02,
571. 'lt' => 2.95799645040426E-02
572. ),
573. 'cup' => array( 'tsp' => 4.80000000000000E+01,
574. 'tbs' => 1.60000000000000E+01,
575. 'oz' => 8.00000000000000E+00,
576. 'cup' => 1.0,
577. 'pt' => 5.00000000000000E-01,
578. 'us_pt' => 5.00000000000000E-01,
579. 'uk_pt' => 4.16428088074541E-01,
580. 'qt' => 2.50000000000000E-01,
581. 'gal' => 6.25000000000000E-02,
582. 'l' => 2.36639716032341E-01,
583. 'lt' => 2.36639716032341E-01
584. ),
585. 'pt' => array( 'tsp' => 9.60000000000000E+01,
586. 'tbs' => 3.20000000000000E+01,
587. 'oz' => 1.60000000000000E+01,
588. 'cup' => 2.00000000000000E+00,
589. 'pt' => 1.0,
590. 'us_pt' => 1.0,
591. 'uk_pt' => 8.32856176149081E-01,
592. 'qt' => 5.00000000000000E-01,
593. 'gal' => 1.25000000000000E-01,
594. 'l' => 4.73279432064682E-01,
595. 'lt' => 4.73279432064682E-01
596. ),
597. 'us_pt' => array( 'tsp' => 9.60000000000000E+01,
598. 'tbs' => 3.20000000000000E+01,
599. 'oz' => 1.60000000000000E+01,
600. 'cup' => 2.00000000000000E+00,
601. 'pt' => 1.0,
602. 'us_pt' => 1.0,
603. 'uk_pt' => 8.32856176149081E-01,
604. 'qt' => 5.00000000000000E-01,
605. 'gal' => 1.25000000000000E-01,
606. 'l' => 4.73279432064682E-01,
607. 'lt' => 4.73279432064682E-01
608. ),
609. 'uk_pt' => array( 'tsp' => 1.15266000000000E+02,
610. 'tbs' => 3.84220000000000E+01,
611. 'oz' => 1.92110000000000E+01,
612. 'cup' => 2.40137500000000E+00,
613. 'pt' => 1.20068750000000E+00,
614. 'us_pt' => 1.20068750000000E+00,
615. 'uk_pt' => 1.0,
616. 'qt' => 6.00343750000000E-01,
617. 'gal' => 1.50085937500000E-01,
618. 'l' => 5.68260698087162E-01,
619. 'lt' => 5.68260698087162E-01
620. ),
621. 'qt' => array( 'tsp' => 1.92000000000000E+02,
622. 'tbs' => 6.40000000000000E+01,
623. 'oz' => 3.20000000000000E+01,
624. 'cup' => 4.00000000000000E+00,
625. 'pt' => 2.00000000000000E+00,
626. 'us_pt' => 2.00000000000000E+00,
627. 'uk_pt' => 1.66571235229816E+00,
628. 'qt' => 1.0,
629. 'gal' => 2.50000000000000E-01,
630. 'l' => 9.46558864129363E-01,
631. 'lt' => 9.46558864129363E-01
632. ),
633. 'gal' => array( 'tsp' => 7.68000000000000E+02,
634. 'tbs' => 2.56000000000000E+02,
635. 'oz' => 1.28000000000000E+02,
636. 'cup' => 1.60000000000000E+01,
637. 'pt' => 8.00000000000000E+00,
638. 'us_pt' => 8.00000000000000E+00,
639. 'uk_pt' => 6.66284940919265E+00,
640. 'qt' => 4.00000000000000E+00,
641. 'gal' => 1.0,
642. 'l' => 3.78623545651745E+00,
643. 'lt' => 3.78623545651745E+00
644. ),
645. 'l' => array( 'tsp' => 2.02840000000000E+02,
646. 'tbs' => 6.76133333333333E+01,
647. 'oz' => 3.38066666666667E+01,
648. 'cup' => 4.22583333333333E+00,
649. 'pt' => 2.11291666666667E+00,
650. 'us_pt' => 2.11291666666667E+00,
651. 'uk_pt' => 1.75975569552166E+00,
652. 'qt' => 1.05645833333333E+00,
653. 'gal' => 2.64114583333333E-01,
654. 'l' => 1.0,
655. 'lt' => 1.0
656. ),
657. 'lt' => array( 'tsp' => 2.02840000000000E+02,
658. 'tbs' => 6.76133333333333E+01,
659. 'oz' => 3.38066666666667E+01,
660. 'cup' => 4.22583333333333E+00,
661. 'pt' => 2.11291666666667E+00,
662. 'us_pt' => 2.11291666666667E+00,
663. 'uk_pt' => 1.75975569552166E+00,
664. 'qt' => 1.05645833333333E+00,
665. 'gal' => 2.64114583333333E-01,
666. 'l' => 1.0,
667. 'lt' => 1.0
668. )
669. )
670. );
673. public static function _parseComplex($complexNumber) {
674. $workString = (string) $complexNumber;
676. $realNumber = $imaginary = 0;
677. // Extract the suffix, if there is one
678. $suffix = substr($workString,-1);
679. if (! is_numeric($suffix)) {
680. $workString = substr($workString,0,-1);
681. } else {
682. $suffix = '';
683. }
685. // Split the input into its Real and Imaginary components
686. $leadingSign = 0;
687. if ( strlen($workString) > 0) {
688. $leadingSign = (($workString{0} == '+') || ($workString{0} == '-')) ? 1 : 0;
689. }
690. $power = '';
691. $realNumber = strtok($workString, '+-');
692. if ( strtoupper( substr($realNumber,-1)) == 'E') {
693. $power = strtok('+-');
694. ++$leadingSign;
695. }
697. $realNumber = substr($workString,0, strlen($realNumber)+strlen($power)+$leadingSign);
699. if ($suffix != '') {
700. $imaginary = substr($workString, strlen($realNumber));
702. if (($imaginary == '') && (($realNumber == '') || ($realNumber == '+') || ($realNumber == '-'))) {
703. $imaginary = $realNumber.'1';
704. $realNumber = '0';
705. } else if ($imaginary == '') {
706. $imaginary = $realNumber;
707. $realNumber = '0';
708. } elseif (($imaginary == '+') || ($imaginary == '-')) {
709. $imaginary .= '1';
710. }
711. }
713. return array( 'real' => $realNumber,
714. 'imaginary' => $imaginary,
715. 'suffix' => $suffix
716. );
717. } // function _parseComplex()
720. private static function _cleanComplex($complexNumber) {
721. if ($complexNumber{0} == '+') $complexNumber = substr($complexNumber,1);
722. if ($complexNumber{0} == '0') $complexNumber = substr($complexNumber,1);
723. if ($complexNumber{0} == '.') $complexNumber = '0'.$complexNumber;
724. if ($complexNumber{0} == '+') $complexNumber = substr($complexNumber,1);
725. return $complexNumber;
726. }
729. private static function _nbrConversionFormat($xVal,$places) {
730. if (! is_null($places)) {
731. if ( strlen($xVal) <= $places) {
732. return substr( str_pad($xVal,$places,'0',STR_PAD_LEFT),-10);
733. } else {
734. return PHPExcel_Calculation_Functions:: NaN();
735. }
736. }
738. return substr($xVal,-10);
739. } // function _nbrConversionFormat()
742. /**
743. * BESSELI
744. *
745. * Returns the modified Bessel function, which is equivalent to the Bessel function evaluated for purely imaginary arguments
746. *
747. * @param float $x
748. * @param float $n
749. * @return int
750. */
751. public static function BESSELI($x, $n) {
752. $x = ( is_null($x)) ? 0.0 : PHPExcel_Calculation_Functions:: flattenSingleValue($x);
753. $n = ( is_null($n)) ? 0.0 : PHPExcel_Calculation_Functions:: flattenSingleValue($n);
755. if (( is_numeric($x)) && ( is_numeric($n))) {
756. $n = floor($n);
757. if ($n < 0) {
758. return PHPExcel_Calculation_Functions:: NaN();
759. }
760. $f_2_PI = 2 * M_PI;
762. if ( abs($x) <= 30) {
763. $fTerm = pow($x / 2, $n) / PHPExcel_Calculation_MathTrig:: FACT($n);
764. $nK = 1;
765. $fResult = $fTerm;
766. $fSqrX = ($x * $x) / 4;
767. do {
768. $fTerm *= $fSqrX;
769. $fTerm /= ($nK * ($nK + $n));
770. $fResult += $fTerm;
771. } while (( abs($fTerm) > 1e-10) && (++$nK < 100));
772. } else {
773. $fXAbs = abs($x);
774. $fResult = exp($fXAbs) / sqrt($f_2_PI * $fXAbs);
775. if (($n && 1) && ($x < 0)) {
776. $fResult = -$fResult;
777. }
778. }
779. return $fResult;
780. }
781. return PHPExcel_Calculation_Functions:: VALUE();
782. } // function BESSELI()
785. /**
786. * BESSELJ
787. *
788. * Returns the Bessel function
789. *
790. * @param float $x
791. * @param float $n
792. * @return int
793. */
794. public static function BESSELJ($x, $n) {
795. $x = ( is_null($x)) ? 0.0 : PHPExcel_Calculation_Functions:: flattenSingleValue($x);
796. $n = ( is_null($n)) ? 0.0 : PHPExcel_Calculation_Functions:: flattenSingleValue($n);
798. if (( is_numeric($x)) && ( is_numeric($n))) {
799. $n = floor($n);
800. if ($n < 0) {
801. return PHPExcel_Calculation_Functions:: NaN();
802. }
803. $f_PI_DIV_2 = M_PI / 2;
804. $f_PI_DIV_4 = M_PI / 4;
806. $fResult = 0;
807. if ( abs($x) <= 30) {
808. $fTerm = pow($x / 2, $n) / PHPExcel_Calculation_MathTrig:: FACT($n);
809. $nK = 1;
810. $fResult = $fTerm;
811. $fSqrX = ($x * $x) / -4;
812. do {
813. $fTerm *= $fSqrX;
814. $fTerm /= ($nK * ($nK + $n));
815. $fResult += $fTerm;
816. } while (( abs($fTerm) > 1e-10) && (++$nK < 100));
817. } else {
818. $fXAbs = abs($x);
819. $fResult = sqrt( M_2DIVPI / $fXAbs) * cos($fXAbs - $n * $f_PI_DIV_2 - $f_PI_DIV_4);
820. if (($n && 1) && ($x < 0)) {
821. $fResult = -$fResult;
822. }
823. }
824. return $fResult;
825. }
826. return PHPExcel_Calculation_Functions:: VALUE();
827. } // function BESSELJ()
830. private static function _Besselk0($fNum) {
831. if ($fNum <= 2) {
832. $fNum2 = $fNum * 0.5;
833. $y = ($fNum2 * $fNum2);
834. $fRet = -log($fNum2) * self:: BESSELI($fNum, 0) +
835. (-0.57721566 + $y * (0.42278420 + $y * (0.23069756 + $y * (0.3488590e-1 + $y * (0.262698e-2 + $y *
836. (0.10750e-3 + $y * 0.74e-5))))));
837. } else {
838. $y = 2 / $fNum;
839. $fRet = exp(-$fNum) / sqrt($fNum) *
840. (1.25331414 + $y * (-0.7832358e-1 + $y * (0.2189568e-1 + $y * (-0.1062446e-1 + $y *
841. (0.587872e-2 + $y * (-0.251540e-2 + $y * 0.53208e-3))))));
842. }
843. return $fRet;
844. } // function _Besselk0()
847. private static function _Besselk1($fNum) {
848. if ($fNum <= 2) {
849. $fNum2 = $fNum * 0.5;
850. $y = ($fNum2 * $fNum2);
851. $fRet = log($fNum2) * self:: BESSELI($fNum, 1) +
852. (1 + $y * (0.15443144 + $y * (-0.67278579 + $y * (-0.18156897 + $y * (-0.1919402e-1 + $y *
853. (-0.110404e-2 + $y * (-0.4686e-4))))))) / $fNum;
854. } else {
855. $y = 2 / $fNum;
856. $fRet = exp(-$fNum) / sqrt($fNum) *
857. (1.25331414 + $y * (0.23498619 + $y * (-0.3655620e-1 + $y * (0.1504268e-1 + $y * (-0.780353e-2 + $y *
858. (0.325614e-2 + $y * (-0.68245e-3)))))));
859. }
860. return $fRet;
861. } // function _Besselk1()
864. /**
865. * BESSELK
866. *
867. * Returns the modified Bessel function, which is equivalent to the Bessel functions evaluated for purely imaginary arguments.
868. *
869. * @param float $x
870. * @param float $ord
871. * @return float
872. */
873. public static function BESSELK($x, $ord) {
874. $x = ( is_null($x)) ? 0.0 : PHPExcel_Calculation_Functions:: flattenSingleValue($x);
875. $ord = ( is_null($ord)) ? 0.0 : PHPExcel_Calculation_Functions:: flattenSingleValue($ord);
877. if (( is_numeric($x)) && ( is_numeric($ord))) {
878. if (($ord < 0) || ($x == 0.0)) {
879. return PHPExcel_Calculation_Functions:: NaN();
880. }
882. switch( floor($ord)) {
883. case 0 : return self::_Besselk0($x);
884. break;
885. case 1 : return self::_Besselk1($x);
886. break;
887. default : $fTox = 2 / $x;
888. $fBkm = self::_Besselk0($x);
889. $fBk = self::_Besselk1($x);
890. for ($n = 1; $n < $ord; ++$n) {
891. $fBkp = $fBkm + $n * $fTox * $fBk;
892. $fBkm = $fBk;
893. $fBk = $fBkp;
894. }
895. }
896. return $fBk;
897. }
898. return PHPExcel_Calculation_Functions:: VALUE();
899. } // function BESSELK()
902. private static function _Bessely0($fNum) {
903. if ($fNum < 8.0) {
904. $y = ($fNum * $fNum);
905. $f1 = -2957821389.0 + $y * (7062834065.0 + $y * (-512359803.6 + $y * (10879881.29 + $y * (-86327.92757 + $y * 228.4622733))));
906. $f2 = 40076544269.0 + $y * (745249964.8 + $y * (7189466.438 + $y * (47447.26470 + $y * (226.1030244 + $y))));
907. $fRet = $f1 / $f2 + M_2DIVPI * self:: BESSELJ($fNum, 0) * log($fNum);
908. } else {
909. $z = 8.0 / $fNum;
910. $y = ($z * $z);
911. $xx = $fNum - 0.785398164;
912. $f1 = 1 + $y * (-0.1098628627e-2 + $y * (0.2734510407e-4 + $y * (-0.2073370639e-5 + $y * 0.2093887211e-6)));
913. $f2 = -0.1562499995e-1 + $y * (0.1430488765e-3 + $y * (-0.6911147651e-5 + $y * (0.7621095161e-6 + $y * (-0.934945152e-7))));
914. $fRet = sqrt( M_2DIVPI / $fNum) * ( sin($xx) * $f1 + $z * cos($xx) * $f2);
915. }
916. return $fRet;
917. } // function _Bessely0()
920. private static function _Bessely1($fNum) {
921. if ($fNum < 8.0) {
922. $y = ($fNum * $fNum);
923. $f1 = $fNum * (-0.4900604943e13 + $y * (0.1275274390e13 + $y * (-0.5153438139e11 + $y * (0.7349264551e9 + $y *
924. (-0.4237922726e7 + $y * 0.8511937935e4)))));
925. $f2 = 0.2499580570e14 + $y * (0.4244419664e12 + $y * (0.3733650367e10 + $y * (0.2245904002e8 + $y *
926. (0.1020426050e6 + $y * (0.3549632885e3 + $y)))));
927. $fRet = $f1 / $f2 + M_2DIVPI * ( self:: BESSELJ($fNum, 1) * log($fNum) - 1 / $fNum);
928. } else {
929. $z = 8.0 / $fNum;
930. $y = ($z * $z);
931. $xx = $fNum - 2.356194491;
932. $f1 = 1 + $y * (0.183105e-2 + $y * (-0.3516396496e-4 + $y * (0.2457520174e-5 + $y * (-0.240337019e6))));
933. $f2 = 0.04687499995 + $y * (-0.2002690873e-3 + $y * (0.8449199096e-5 + $y * (-0.88228987e-6 + $y * 0.105787412e-6)));
934. $fRet = sqrt( M_2DIVPI / $fNum) * ( sin($xx) * $f1 + $z * cos($xx) * $f2);
935. #i12430# ...but this seems to work much better.
936. // $fRet = sqrt(M_2DIVPI / $fNum) * sin($fNum - 2.356194491);
937. }
938. return $fRet;
939. } // function _Bessely1()
942. /**
943. * BESSELY
944. *
945. * Returns the Bessel function, which is also called the Weber function or the Neumann function.
946. *
947. * @param float $x
948. * @param float $n
949. * @return int
950. */
951. public static function BESSELY($x, $ord) {
952. $x = ( is_null($x)) ? 0.0 : PHPExcel_Calculation_Functions:: flattenSingleValue($x);
953. $ord = ( is_null($ord)) ? 0.0 : PHPExcel_Calculation_Functions:: flattenSingleValue($ord);
955. if (( is_numeric($x)) && ( is_numeric($ord))) {
956. if (($ord < 0) || ($x == 0.0)) {
957. return PHPExcel_Calculation_Functions:: NaN();
958. }
960. switch( floor($ord)) {
961. case 0 : return self::_Bessely0($x);
962. break;
963. case 1 : return self::_Bessely1($x);
964. break;
965. default: $fTox = 2 / $x;
966. $fBym = self::_Bessely0($x);
967. $fBy = self::_Bessely1($x);
968. for ($n = 1; $n < $ord; ++$n) {
969. $fByp = $n * $fTox * $fBy - $fBym;
970. $fBym = $fBy;
971. $fBy = $fByp;
972. }
973. }
974. return $fBy;
975. }
976. return PHPExcel_Calculation_Functions:: VALUE();
977. } // function BESSELY()
980. /**
981. * BINTODEC
982. *
983. * Return a binary value as Decimal.
984. *
985. * @param string $x
986. * @return string
987. */
988. public static function BINTODEC($x) {
989. $x = PHPExcel_Calculation_Functions:: flattenSingleValue($x);
991. if ( is_bool($x)) {
992. if ( PHPExcel_Calculation_Functions:: getCompatibilityMode() == PHPExcel_Calculation_Functions:: COMPATIBILITY_OPENOFFICE) {
993. $x = (int) $x;
994. } else {
995. return PHPExcel_Calculation_Functions:: VALUE();
996. }
997. }
998. if ( PHPExcel_Calculation_Functions:: getCompatibilityMode() == PHPExcel_Calculation_Functions:: COMPATIBILITY_GNUMERIC) {
999. $x = floor($x);
1000. }
1001. $x = (string) $x;
1002. if ( strlen($x) > preg_match_all('/[01]/',$x,$out)) {
1003. return PHPExcel_Calculation_Functions:: NaN();
1004. }
1005. if ( strlen($x) > 10) {
1006. return PHPExcel_Calculation_Functions:: NaN();
1007. } elseif ( strlen($x) == 10) {
1008. // Two's Complement
1009. $x = substr($x,-9);
1010. return '-'.(512-bindec($x));
1011. }
1012. return bindec($x);
1013. } // function BINTODEC()
1016. /**
1017. * BINTOHEX
1018. *
1019. * Return a binary value as Hex.
1020. *
1021. * @param string $x
1022. * @return string
1023. */
1024. public static function BINTOHEX($x, $places=null) {
1025. $x = floor( PHPExcel_Calculation_Functions:: flattenSingleValue($x));
1026. $places = PHPExcel_Calculation_Functions:: flattenSingleValue($places);
1028. if ( is_bool($x)) {
1029. if ( PHPExcel_Calculation_Functions:: getCompatibilityMode() == PHPExcel_Calculation_Functions:: COMPATIBILITY_OPENOFFICE) {
1030. $x = (int) $x;
1031. } else {
1032. return PHPExcel_Calculation_Functions:: VALUE();
1033. }
1034. }
1035. if ( PHPExcel_Calculation_Functions:: getCompatibilityMode() == PHPExcel_Calculation_Functions:: COMPATIBILITY_GNUMERIC) {
1036. $x = floor($x);
1037. }
1038. $x = (string) $x;
1039. if ( strlen($x) > preg_match_all('/[01]/',$x,$out)) {
1040. return PHPExcel_Calculation_Functions:: NaN();
1041. }
1042. if ( strlen($x) > 10) {
1043. return PHPExcel_Calculation_Functions:: NaN();
1044. } elseif ( strlen($x) == 10) {
1045. // Two's Complement
1046. return str_repeat('F',8).substr( strtoupper( dechex( bindec( substr($x,-9)))),-2);
1047. }
1048. $hexVal = (string) strtoupper( dechex( bindec($x)));
1050. return self::_nbrConversionFormat($hexVal,$places);
1051. } // function BINTOHEX()
1054. /**
1055. * BINTOOCT
1056. *
1057. * Return a binary value as Octal.
1058. *
1059. * @param string $x
1060. * @return string
1061. */
1062. public static function BINTOOCT($x, $places=null) {
1063. $x = floor( PHPExcel_Calculation_Functions:: flattenSingleValue($x));
1064. $places = PHPExcel_Calculation_Functions:: flattenSingleValue($places);
1066. if ( is_bool($x)) {
1067. if ( PHPExcel_Calculation_Functions:: getCompatibilityMode() == PHPExcel_Calculation_Functions:: COMPATIBILITY_OPENOFFICE) {
1068. $x = (int) $x;
1069. } else {
1070. return PHPExcel_Calculation_Functions:: VALUE();
1071. }
1072. }
1073. if ( PHPExcel_Calculation_Functions:: getCompatibilityMode() == PHPExcel_Calculation_Functions:: COMPATIBILITY_GNUMERIC) {
1074. $x = floor($x);
1075. }
1076. $x = (string) $x;
1077. if ( strlen($x) > preg_match_all('/[01]/',$x,$out)) {
1078. return PHPExcel_Calculation_Functions:: NaN();
1079. }
1080. if ( strlen($x) > 10) {
1081. return PHPExcel_Calculation_Functions:: NaN();
1082. } elseif ( strlen($x) == 10) {
1083. // Two's Complement
1084. return str_repeat('7',7).substr( strtoupper( decoct( bindec( substr($x,-9)))),-3);
1085. }
1086. $octVal = (string) decoct( bindec($x));
1088. return self::_nbrConversionFormat($octVal,$places);
1089. } // function BINTOOCT()
1092. /**
1093. * DECTOBIN
1094. *
1095. * Return an octal value as binary.
1096. *
1097. * @param string $x
1098. * @return string
1099. */
1100. public static function DECTOBIN($x, $places=null) {
1101. $x = PHPExcel_Calculation_Functions:: flattenSingleValue($x);
1102. $places = PHPExcel_Calculation_Functions:: flattenSingleValue($places);
1104. if ( is_bool($x)) {
1105. if ( PHPExcel_Calculation_Functions:: getCompatibilityMode() == PHPExcel_Calculation_Functions:: COMPATIBILITY_OPENOFFICE) {
1106. $x = (int) $x;
1107. } else {
1108. return PHPExcel_Calculation_Functions:: VALUE();
1109. }
1110. }
1111. $x = (string) $x;
1112. if ( strlen($x) > preg_match_all('/[-0123456789.]/',$x,$out)) {
1113. return PHPExcel_Calculation_Functions:: VALUE();
1114. }
1115. $x = (string) floor($x);
1116. $r = decbin($x);
1117. if ( strlen($r) == 32) {
1118. // Two's Complement
1119. $r = substr($r,-10);
1120. } elseif ( strlen($r) > 11) {
1121. return PHPExcel_Calculation_Functions:: NaN();
1122. }
1124. return self::_nbrConversionFormat($r,$places);
1125. } // function DECTOBIN()
1128. /**
1129. * DECTOHEX
1130. *
1131. * Return an octal value as binary.
1132. *
1133. * @param string $x
1134. * @return string
1135. */
1136. public static function DECTOHEX($x, $places=null) {
1137. $x = PHPExcel_Calculation_Functions:: flattenSingleValue($x);
1138. $places = PHPExcel_Calculation_Functions:: flattenSingleValue($places);
1140. if ( is_bool($x)) {
1141. if ( PHPExcel_Calculation_Functions:: getCompatibilityMode() == PHPExcel_Calculation_Functions:: COMPATIBILITY_OPENOFFICE) {
1142. $x = (int) $x;
1143. } else {
1144. return PHPExcel_Calculation_Functions:: VALUE();
1145. }
1146. }
1147. $x = (string) $x;
1148. if ( strlen($x) > preg_match_all('/[-0123456789.]/',$x,$out)) {
1149. return PHPExcel_Calculation_Functions:: VALUE();
1150. }
1151. $x = (string) floor($x);
1152. $r = strtoupper( dechex($x));
1153. if ( strlen($r) == 8) {
1154. // Two's Complement
1155. $r = 'FF'.$r;
1156. }
1158. return self::_nbrConversionFormat($r,$places);
1159. } // function DECTOHEX()
1162. /**
1163. * DECTOOCT
1164. *
1165. * Return an octal value as binary.
1166. *
1167. * @param string $x
1168. * @return string
1169. */
1170. public static function DECTOOCT($x, $places=null) {
1171. $x = PHPExcel_Calculation_Functions:: flattenSingleValue($x);
1172. $places = PHPExcel_Calculation_Functions:: flattenSingleValue($places);
1174. if ( is_bool($x)) {
1175. if ( PHPExcel_Calculation_Functions:: getCompatibilityMode() == PHPExcel_Calculation_Functions:: COMPATIBILITY_OPENOFFICE) {
1176. $x = (int) $x;
1177. } else {
1178. return PHPExcel_Calculation_Functions:: VALUE();
1179. }
1180. }
1181. $x = (string) $x;
1182. if ( strlen($x) > preg_match_all('/[-0123456789.]/',$x,$out)) {
1183. return PHPExcel_Calculation_Functions:: VALUE();
1184. }
1185. $x = (string) floor($x);
1186. $r = decoct($x);
1187. if ( strlen($r) == 11) {
1188. // Two's Complement
1189. $r = substr($r,-10);
1190. }
1192. return self::_nbrConversionFormat($r,$places);
1193. } // function DECTOOCT()
1196. /**
1197. * HEXTOBIN
1198. *
1199. * Return a hex value as binary.
1200. *
1201. * @param string $x
1202. * @return string
1203. */
1204. public static function HEXTOBIN($x, $places=null) {
1205. $x = PHPExcel_Calculation_Functions:: flattenSingleValue($x);
1206. $places = PHPExcel_Calculation_Functions:: flattenSingleValue($places);
1208. if ( is_bool($x)) {
1209. return PHPExcel_Calculation_Functions:: VALUE();
1210. }
1211. $x = (string) $x;
1212. if ( strlen($x) > preg_match_all('/[0123456789ABCDEF]/', strtoupper($x),$out)) {
1213. return PHPExcel_Calculation_Functions:: NaN();
1214. }
1215. $binVal = decbin( hexdec($x));
1217. return substr(self::_nbrConversionFormat($binVal,$places),-10);
1218. } // function HEXTOBIN()
1221. /**
1222. * HEXTODEC
1223. *
1224. * Return a hex value as octal.
1225. *
1226. * @param string $x
1227. * @return string
1228. */
1229. public static function HEXTODEC($x) {
1230. $x = PHPExcel_Calculation_Functions:: flattenSingleValue($x);
1232. if ( is_bool($x)) {
1233. return PHPExcel_Calculation_Functions:: VALUE();
1234. }
1235. $x = (string) $x;
1236. if ( strlen($x) > preg_match_all('/[0123456789ABCDEF]/', strtoupper($x),$out)) {
1237. return PHPExcel_Calculation_Functions:: NaN();
1238. }
1239. return hexdec($x);
1240. } // function HEXTODEC()
1243. /**
1244. * HEXTOOCT
1245. *
1246. * Return a hex value as octal.
1247. *
1248. * @param string $x
1249. * @return string
1250. */
1251. public static function HEXTOOCT($x, $places=null) {
1252. $x = PHPExcel_Calculation_Functions:: flattenSingleValue($x);
1253. $places = PHPExcel_Calculation_Functions:: flattenSingleValue($places);
1255. if ( is_bool($x)) {
1256. return PHPExcel_Calculation_Functions:: VALUE();
1257. }
1258. $x = (string) $x;
1259. if ( strlen($x) > preg_match_all('/[0123456789ABCDEF]/', strtoupper($x),$out)) {
1260. return PHPExcel_Calculation_Functions:: NaN();
1261. }
1262. $octVal = decoct( hexdec($x));
1264. return self::_nbrConversionFormat($octVal,$places);
1265. } // function HEXTOOCT()
1268. /**
1269. * OCTTOBIN
1270. *
1271. * Return an octal value as binary.
1272. *
1273. * @param string $x
1274. * @return string
1275. */
1276. public static function OCTTOBIN($x, $places=null) {
1277. $x = PHPExcel_Calculation_Functions:: flattenSingleValue($x);
1278. $places = PHPExcel_Calculation_Functions:: flattenSingleValue($places);
1280. if ( is_bool($x)) {
1281. return PHPExcel_Calculation_Functions:: VALUE();
1282. }
1283. $x = (string) $x;
1284. if ( preg_match_all('/[01234567]/',$x,$out) != strlen($x)) {
1285. return PHPExcel_Calculation_Functions:: NaN();
1286. }
1287. $r = decbin( octdec($x));
1289. return self::_nbrConversionFormat($r,$places);
1290. } // function OCTTOBIN()
1293. /**
1294. * OCTTODEC
1295. *
1296. * Return an octal value as binary.
1297. *
1298. * @param string $x
1299. * @return string
1300. */
1301. public static function OCTTODEC($x) {
1302. $x = PHPExcel_Calculation_Functions:: flattenSingleValue($x);
1304. if ( is_bool($x)) {
1305. return PHPExcel_Calculation_Functions:: VALUE();
1306. }
1307. $x = (string) $x;
1308. if ( preg_match_all('/[01234567]/',$x,$out) != strlen($x)) {
1309. return PHPExcel_Calculation_Functions:: NaN();
1310. }
1311. return octdec($x);
1312. } // function OCTTODEC()
1315. /**
1316. * OCTTOHEX
1317. *
1318. * Return an octal value as hex.
1319. *
1320. * @param string $x
1321. * @return string
1322. */
1323. public static function OCTTOHEX($x, $places=null) {
1324. $x = PHPExcel_Calculation_Functions:: flattenSingleValue($x);
1325. $places = PHPExcel_Calculation_Functions:: flattenSingleValue($places);
1327. if ( is_bool($x)) {
1328. return PHPExcel_Calculation_Functions:: VALUE();
1329. }
1330. $x = (string) $x;
1331. if ( preg_match_all('/[01234567]/',$x,$out) != strlen($x)) {
1332. return PHPExcel_Calculation_Functions:: NaN();
1333. }
1334. $hexVal = strtoupper( dechex( octdec($x)));
1336. return self::_nbrConversionFormat($hexVal,$places);
1337. } // function OCTTOHEX()
1340. /**
1341. * COMPLEX
1342. *
1343. * returns a complex number of the form x + yi or x + yj.
1344. *
1345. * @param float $realNumber
1346. * @param float $imaginary
1347. * @param string $suffix
1348. * @return string
1349. */
1350. public static function COMPLEX($realNumber=0.0, $imaginary=0.0, $suffix='i') {
1351. $realNumber = ( is_null($realNumber)) ? 0.0 : (float) PHPExcel_Calculation_Functions:: flattenSingleValue($realNumber);
1352. $imaginary = ( is_null($imaginary)) ? 0.0 : (float) PHPExcel_Calculation_Functions:: flattenSingleValue($imaginary);
1353. $suffix = ( is_null($suffix)) ? 'i' : PHPExcel_Calculation_Functions:: flattenSingleValue($suffix);
1355. if ((( is_numeric($realNumber)) && ( is_numeric($imaginary))) &&
1356. (($suffix == 'i') || ($suffix == 'j') || ($suffix == ''))) {
1357. if ($suffix == '') $suffix = 'i';
1358. if ($realNumber == 0.0) {
1359. if ($imaginary == 0.0) {
1360. return (string) '0';
1361. } elseif ($imaginary == 1.0) {
1362. return (string) $suffix;
1363. } elseif ($imaginary == -1.0) {
1364. return (string) '-'.$suffix;
1365. }
1366. return (string) $imaginary.$suffix;
1367. } elseif ($imaginary == 0.0) {
1368. return (string) $realNumber;
1369. } elseif ($imaginary == 1.0) {
1370. return (string) $realNumber.'+'.$suffix;
1371. } elseif ($imaginary == -1.0) {
1372. return (string) $realNumber.'-'.$suffix;
1373. }
1374. if ($imaginary > 0) { $imaginary = (string) '+'.$imaginary; }
1375. return (string) $realNumber.$imaginary.$suffix;
1376. }
1378. return PHPExcel_Calculation_Functions:: VALUE();
1379. } // function COMPLEX()
1382. /**
1383. * IMAGINARY
1384. *
1385. * Returns the imaginary coefficient of a complex number in x + yi or x + yj text format.
1386. *
1387. * @param string $complexNumber
1388. * @return real
1389. */
1390. public static function IMAGINARY($complexNumber) {
1391. $complexNumber = PHPExcel_Calculation_Functions:: flattenSingleValue($complexNumber);
1393. $parsedComplex = self::_parseComplex($complexNumber);
1394. if (! is_array($parsedComplex)) {
1395. return $parsedComplex;
1396. }
1397. return $parsedComplex['imaginary'];
1398. } // function IMAGINARY()
1401. /**
1402. * IMREAL
1403. *
1404. * Returns the real coefficient of a complex number in x + yi or x + yj text format.
1405. *
1406. * @param string $complexNumber
1407. * @return real
1408. */
1409. public static function IMREAL($complexNumber) {
1410. $complexNumber = PHPExcel_Calculation_Functions:: flattenSingleValue($complexNumber);
1412. $parsedComplex = self::_parseComplex($complexNumber);
1413. if (! is_array($parsedComplex)) {
1414. return $parsedComplex;
1415. }
1416. return $parsedComplex['real'];
1417. } // function IMREAL()
1420. /**
1421. * IMABS
1422. *
1423. * Returns the absolute value (modulus) of a complex number in x + yi or x + yj text format.
1424. *
1425. * @param string $complexNumber
1426. * @return real
1427. */
1428. public static function IMABS($complexNumber) {
1429. $complexNumber = PHPExcel_Calculation_Functions:: flattenSingleValue($complexNumber);
1431. $parsedComplex = self::_parseComplex($complexNumber);
1432. if (! is_array($parsedComplex)) {
1433. return $parsedComplex;
1434. }
1435. return sqrt(($parsedComplex['real'] * $parsedComplex['real']) + ($parsedComplex['imaginary'] * $parsedComplex['imaginary']));
1436. } // function IMABS()
1439. /**
1440. * IMARGUMENT
1441. *
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. *
1444. * @param string $complexNumber
1445. * @return string
1446. */
1447. public static function IMARGUMENT($complexNumber) {
1448. $complexNumber = PHPExcel_Calculation_Functions:: flattenSingleValue($complexNumber);
1450. $parsedComplex = self::_parseComplex($complexNumber);
1451. if (! is_array($parsedComplex)) {
1452. return $parsedComplex;
1453. }
1455. if ($parsedComplex['real'] == 0.0) {
1456. if ($parsedComplex['imaginary'] == 0.0) {
1457. return 0.0;
1458. } elseif($parsedComplex['imaginary'] < 0.0) {
1459. return M_PI / -2;
1460. } else {
1461. return M_PI / 2;
1462. }
1463. } elseif ($parsedComplex['real'] > 0.0) {
1464. return atan($parsedComplex['imaginary'] / $parsedComplex['real']);
1465. } elseif ($parsedComplex['imaginary'] < 0.0) {
1466. return 0 - (M_PI - atan( abs($parsedComplex['imaginary']) / abs($parsedComplex['real'])));
1467. } else {
1468. return M_PI - atan($parsedComplex['imaginary'] / abs($parsedComplex['real']));
1469. }
1470. } // function IMARGUMENT()
1473. /**
1474. * IMCONJUGATE
1475. *
1476. * Returns the complex conjugate of a complex number in x + yi or x + yj text format.
1477. *
1478. * @param string $complexNumber
1479. * @return string
1480. */
1481. public static function IMCONJUGATE($complexNumber) {
1482. $complexNumber = PHPExcel_Calculation_Functions:: flattenSingleValue($complexNumber);
1484. $parsedComplex = self::_parseComplex($complexNumber);
1486. if (! is_array($parsedComplex)) {
1487. return $parsedComplex;
1488. }
1490. if ($parsedComplex['imaginary'] == 0.0) {
1491. return $parsedComplex['real'];
1492. } else {
1493. return self::_cleanComplex(self:: COMPLEX($parsedComplex['real'], 0 - $parsedComplex['imaginary'], $parsedComplex['suffix']));
1494. }
1495. } // function IMCONJUGATE()
1498. /**
1499. * IMCOS
1500. *
1501. * Returns the cosine of a complex number in x + yi or x + yj text format.
1502. *
1503. * @param string $complexNumber
1504. * @return string
1505. */
1506. public static function IMCOS($complexNumber) {
1507. $complexNumber = PHPExcel_Calculation_Functions:: flattenSingleValue($complexNumber);
1509. $parsedComplex = self::_parseComplex($complexNumber);
1510. if (! is_array($parsedComplex)) {
1511. return $parsedComplex;
1512. }
1514. if ($parsedComplex['imaginary'] == 0.0) {
1515. return cos($parsedComplex['real']);
1516. } else {
1517. return self:: IMCONJUGATE(self:: COMPLEX( cos($parsedComplex['real']) * cosh($parsedComplex['imaginary']), sin($parsedComplex['real']) * sinh($parsedComplex['imaginary']),$parsedComplex['suffix']));
1518. }
1519. } // function IMCOS()
1522. /**
1523. * IMSIN
1524. *
1525. * Returns the sine of a complex number in x + yi or x + yj text format.
1526. *
1527. * @param string $complexNumber
1528. * @return string
1529. */
1530. public static function IMSIN($complexNumber) {
1531. $complexNumber = PHPExcel_Calculation_Functions:: flattenSingleValue($complexNumber);
1533. $parsedComplex = self::_parseComplex($complexNumber);
1534. if (! is_array($parsedComplex)) {
1535. return $parsedComplex;
1536. }
1538. if ($parsedComplex['imaginary'] == 0.0) {
1539. return sin($parsedComplex['real']);
1540. } else {
1541. return self:: COMPLEX( sin($parsedComplex['real']) * cosh($parsedComplex['imaginary']), cos($parsedComplex['real']) * sinh($parsedComplex['imaginary']),$parsedComplex['suffix']);
1542. }
1543. } // function IMSIN()
1546. /**
1547. * IMSQRT
1548. *
1549. * Returns the square root of a complex number in x + yi or x + yj text format.
1550. *
1551. * @param string $complexNumber
1552. * @return string
1553. */
1554. public static function IMSQRT($complexNumber) {
1555. $complexNumber = PHPExcel_Calculation_Functions:: flattenSingleValue($complexNumber);
1557. $parsedComplex = self::_parseComplex($complexNumber);
1558. if (! is_array($parsedComplex)) {
1559. return $parsedComplex;
1560. }
1562. $theta = self:: IMARGUMENT($complexNumber);
1563. $d1 = cos($theta / 2);
1564. $d2 = sin($theta / 2);
1565. $r = sqrt( sqrt(($parsedComplex['real'] * $parsedComplex['real']) + ($parsedComplex['imaginary'] * $parsedComplex['imaginary'])));
1567. if ($parsedComplex['suffix'] == '') {
1568. return self:: COMPLEX($d1 * $r,$d2 * $r);
1569. } else {
1570. return self:: COMPLEX($d1 * $r,$d2 * $r,$parsedComplex['suffix']);
1571. }
1572. } // function IMSQRT()
1575. /**
1576. * IMLN
1577. *
1578. * Returns the natural logarithm of a complex number in x + yi or x + yj text format.
1579. *
1580. * @param string $complexNumber
1581. * @return string
1582. */
1583. public static function IMLN($complexNumber) {
1584. $complexNumber = PHPExcel_Calculation_Functions:: flattenSingleValue($complexNumber);
1586. $parsedComplex = self::_parseComplex($complexNumber);
1587. if (! is_array($parsedComplex)) {
1588. return $parsedComplex;
1589. }
1591. if (($parsedComplex['real'] == 0.0) && ($parsedComplex['imaginary'] == 0.0)) {
1592. return PHPExcel_Calculation_Functions:: NaN();
1593. }
1595. $logR = log( sqrt(($parsedComplex['real'] * $parsedComplex['real']) + ($parsedComplex['imaginary'] * $parsedComplex['imaginary'])));
1596. $t = self:: IMARGUMENT($complexNumber);
1598. if ($parsedComplex['suffix'] == '') {
1599. return self:: COMPLEX($logR,$t);
1600. } else {
1601. return self:: COMPLEX($logR,$t,$parsedComplex['suffix']);
1602. }
1603. } // function IMLN()
1606. /**
1607. * IMLOG10
1608. *
1609. * Returns the common logarithm (base 10) of a complex number in x + yi or x + yj text format.
1610. *
1611. * @param string $complexNumber
1612. * @return string
1613. */
1614. public static function IMLOG10($complexNumber) {
1615. $complexNumber = PHPExcel_Calculation_Functions:: flattenSingleValue($complexNumber);
1617. $parsedComplex = self::_parseComplex($complexNumber);
1618. if (! is_array($parsedComplex)) {
1619. return $parsedComplex;
1620. }
1622. if (($parsedComplex['real'] == 0.0) && ($parsedComplex['imaginary'] == 0.0)) {
1623. return PHPExcel_Calculation_Functions:: NaN();
1624. } elseif (($parsedComplex['real'] > 0.0) && ($parsedComplex['imaginary'] == 0.0)) {
1625. return log10($parsedComplex['real']);
1626. }
1628. return self:: IMPRODUCT( log10( EULER),self:: IMLN($complexNumber));
1629. } // function IMLOG10()
1632. /**
1633. * IMLOG2
1634. *
1635. * Returns the common logarithm (base 10) of a complex number in x + yi or x + yj text format.
1636. *
1637. * @param string $complexNumber
1638. * @return string
1639. */
1640. public static function IMLOG2($complexNumber) {
1641. $complexNumber = PHPExcel_Calculation_Functions:: flattenSingleValue($complexNumber);
1643. $parsedComplex = self::_parseComplex($complexNumber);
1644. if (! is_array($parsedComplex)) {
1645. return $parsedComplex;
1646. }
1648. if (($parsedComplex['real'] == 0.0) && ($parsedComplex['imaginary'] == 0.0)) {
1649. return PHPExcel_Calculation_Functions:: NaN();
1650. } elseif (($parsedComplex['real'] > 0.0) && ($parsedComplex['imaginary'] == 0.0)) {
1651. return log($parsedComplex['real'],2);
1652. }
1654. return self:: IMPRODUCT( log( EULER,2),self:: IMLN($complexNumber));
1655. } // function IMLOG2()
1658. /**
1659. * IMEXP
1660. *
1661. * Returns the exponential of a complex number in x + yi or x + yj text format.
1662. *
1663. * @param string $complexNumber
1664. * @return string
1665. */
1666. public static function IMEXP($complexNumber) {
1667. $complexNumber = PHPExcel_Calculation_Functions:: flattenSingleValue($complexNumber);
1669. $parsedComplex = self::_parseComplex($complexNumber);
1670. if (! is_array($parsedComplex)) {
1671. return $parsedComplex;
1672. }
1674. if (($parsedComplex['real'] == 0.0) && ($parsedComplex['imaginary'] == 0.0)) {
1675. return '1';
1676. }
1678. $e = exp($parsedComplex['real']);
1679. $eX = $e * cos($parsedComplex['imaginary']);
1680. $eY = $e * sin($parsedComplex['imaginary']);
1682. if ($parsedComplex['suffix'] == '') {
1683. return self:: COMPLEX($eX,$eY);
1684. } else {
1685. return self:: COMPLEX($eX,$eY,$parsedComplex['suffix']);
1686. }
1687. } // function IMEXP()
1690. /**
1691. * IMPOWER
1692. *
1693. * Returns a complex number in x + yi or x + yj text format raised to a power.
1694. *
1695. * @param string $complexNumber
1696. * @return string
1697. */
1698. public static function IMPOWER($complexNumber,$realNumber) {
1699. $complexNumber = PHPExcel_Calculation_Functions:: flattenSingleValue($complexNumber);
1700. $realNumber = PHPExcel_Calculation_Functions:: flattenSingleValue($realNumber);
1702. if (! is_numeric($realNumber)) {
1703. return PHPExcel_Calculation_Functions:: VALUE();
1704. }
1706. $parsedComplex = self::_parseComplex($complexNumber);
1707. if (! is_array($parsedComplex)) {
1708. return $parsedComplex;
1709. }
1711. $r = sqrt(($parsedComplex['real'] * $parsedComplex['real']) + ($parsedComplex['imaginary'] * $parsedComplex['imaginary']));
1712. $rPower = pow($r,$realNumber);
1713. $theta = self:: IMARGUMENT($complexNumber) * $realNumber;
1714. if ($theta == 0) {
1715. return 1;
1716. } elseif ($parsedComplex['imaginary'] == 0.0) {
1717. return self:: COMPLEX($rPower * cos($theta),$rPower * sin($theta),$parsedComplex['suffix']);
1718. } else {
1719. return self:: COMPLEX($rPower * cos($theta),$rPower * sin($theta),$parsedComplex['suffix']);
1720. }
1721. } // function IMPOWER()
1724. /**
1725. * IMDIV
1726. *
1727. * Returns the quotient of two complex numbers in x + yi or x + yj text format.
1728. *
1729. * @param string $complexDividend
1730. * @param string $complexDivisor
1731. * @return real
1732. */
1733. public static function IMDIV($complexDividend,$complexDivisor) {
1734. $complexDividend = PHPExcel_Calculation_Functions:: flattenSingleValue($complexDividend);
1735. $complexDivisor = PHPExcel_Calculation_Functions:: flattenSingleValue($complexDivisor);
1737. $parsedComplexDividend = self::_parseComplex($complexDividend);
1738. if (! is_array($parsedComplexDividend)) {
1739. return $parsedComplexDividend;
1740. }
1742. $parsedComplexDivisor = self::_parseComplex($complexDivisor);
1743. if (! is_array($parsedComplexDivisor)) {
1744. return $parsedComplexDividend;
1745. }
1747. if (($parsedComplexDividend['suffix'] != '') && ($parsedComplexDivisor['suffix'] != '') &&
1748. ($parsedComplexDividend['suffix'] != $parsedComplexDivisor['suffix'])) {
1749. return PHPExcel_Calculation_Functions:: NaN();
1750. }
1751. if (($parsedComplexDividend['suffix'] != '') && ($parsedComplexDivisor['suffix'] == '')) {
1752. $parsedComplexDivisor['suffix'] = $parsedComplexDividend['suffix'];
1753. }
1755. $d1 = ($parsedComplexDividend['real'] * $parsedComplexDivisor['real']) + ($parsedComplexDividend['imaginary'] * $parsedComplexDivisor['imaginary']);
1756. $d2 = ($parsedComplexDividend['imaginary'] * $parsedComplexDivisor['real']) - ($parsedComplexDividend['real'] * $parsedComplexDivisor['imaginary']);
1757. $d3 = ($parsedComplexDivisor['real'] * $parsedComplexDivisor['real']) + ($parsedComplexDivisor['imaginary'] * $parsedComplexDivisor['imaginary']);
1759. $r = $d1/$d3;
1760. $i = $d2/$d3;
1762. if ($i > 0.0) {
1763. return self::_cleanComplex($r.'+'.$i.$parsedComplexDivisor['suffix']);
1764. } elseif ($i < 0.0) {
1765. return self::_cleanComplex($r.$i.$parsedComplexDivisor['suffix']);
1766. } else {
1767. return $r;
1768. }
1769. } // function IMDIV()
1772. /**
1773. * IMSUB
1774. *
1775. * Returns the difference of two complex numbers in x + yi or x + yj text format.
1776. *
1777. * @param string $complexNumber1
1778. * @param string $complexNumber2
1779. * @return real
1780. */
1781. public static function IMSUB($complexNumber1,$complexNumber2) {
1782. $complexNumber1 = PHPExcel_Calculation_Functions:: flattenSingleValue($complexNumber1);
1783. $complexNumber2 = PHPExcel_Calculation_Functions:: flattenSingleValue($complexNumber2);
1785. $parsedComplex1 = self::_parseComplex($complexNumber1);
1786. if (! is_array($parsedComplex1)) {
1787. return $parsedComplex1;
1788. }
1790. $parsedComplex2 = self::_parseComplex($complexNumber2);
1791. if (! is_array($parsedComplex2)) {
1792. return $parsedComplex2;
1793. }
1795. if ((($parsedComplex1['suffix'] != '') && ($parsedComplex2['suffix'] != '')) &&
1796. ($parsedComplex1['suffix'] != $parsedComplex2['suffix'])) {
1797. return PHPExcel_Calculation_Functions:: NaN();
1798. } elseif (($parsedComplex1['suffix'] == '') && ($parsedComplex2['suffix'] != '')) {
1799. $parsedComplex1['suffix'] = $parsedComplex2['suffix'];
1800. }
1802. $d1 = $parsedComplex1['real'] - $parsedComplex2['real'];
1803. $d2 = $parsedComplex1['imaginary'] - $parsedComplex2['imaginary'];
1805. return self:: COMPLEX($d1,$d2,$parsedComplex1['suffix']);
1806. } // function IMSUB()
1809. /**
1810. * IMSUM
1811. *
1812. * Returns the sum of two or more complex numbers in x + yi or x + yj text format.
1813. *
1814. * @param array of mixed Data Series
1815. * @return real
1816. */
1817. public static function IMSUM() {
1818. // Return value
1819. $returnValue = self::_parseComplex('0');
1820. $activeSuffix = '';
1822. // Loop through the arguments
1823. $aArgs = PHPExcel_Calculation_Functions:: flattenArray( func_get_args());
1824. foreach ($aArgs as $arg) {
1825. $parsedComplex = self::_parseComplex($arg);
1826. if (! is_array($parsedComplex)) {
1827. return $parsedComplex;
1828. }
1830. if ($activeSuffix == '') {
1831. $activeSuffix = $parsedComplex['suffix'];
1832. } elseif (($parsedComplex['suffix'] != '') && ($activeSuffix != $parsedComplex['suffix'])) {
1833. return PHPExcel_Calculation_Functions:: VALUE();
1834. }
1836. $returnValue['real'] += $parsedComplex['real'];
1837. $returnValue['imaginary'] += $parsedComplex['imaginary'];
1838. }
1840. if ($returnValue['imaginary'] == 0.0) { $activeSuffix = ''; }
1841. return self:: COMPLEX($returnValue['real'],$returnValue['imaginary'],$activeSuffix);
1842. } // function IMSUM()
1845. /**
1846. * IMPRODUCT
1847. *
1848. * Returns the product of two or more complex numbers in x + yi or x + yj text format.
1849. *
1850. * @param array of mixed Data Series
1851. * @return real
1852. */
1853. public static function IMPRODUCT() {
1854. // Return value
1855. $returnValue = self::_parseComplex('1');
1856. $activeSuffix = '';
1858. // Loop through the arguments
1859. $aArgs = PHPExcel_Calculation_Functions:: flattenArray( func_get_args());
1860. foreach ($aArgs as $arg) {
1861. $parsedComplex = self::_parseComplex($arg);
1862. if (! is_array($parsedComplex)) {
1863. return $parsedComplex;
1864. }
1865. $workValue = $returnValue;
1866. if (($parsedComplex['suffix'] != '') && ($activeSuffix == '')) {
1867. $activeSuffix = $parsedComplex['suffix'];
1868. } elseif (($parsedComplex['suffix'] != '') && ($activeSuffix != $parsedComplex['suffix'])) {
1869. return PHPExcel_Calculation_Functions:: NaN();
1870. }
1871. $returnValue['real'] = ($workValue['real'] * $parsedComplex['real']) - ($workValue['imaginary'] * $parsedComplex['imaginary']);
1872. $returnValue['imaginary'] = ($workValue['real'] * $parsedComplex['imaginary']) + ($workValue['imaginary'] * $parsedComplex['real']);
1873. }
1875. if ($returnValue['imaginary'] == 0.0) { $activeSuffix = ''; }
1876. return self:: COMPLEX($returnValue['real'],$returnValue['imaginary'],$activeSuffix);
1877. } // function IMPRODUCT()
1880. /**
1881. * DELTA
1882. *
1883. * Tests whether two values are equal. Returns 1 if number1 = number2; returns 0 otherwise.
1884. *
1885. * @param float $a
1886. * @param float $b
1887. * @return int
1888. */
1889. public static function DELTA($a, $b=0) {
1890. $a = PHPExcel_Calculation_Functions:: flattenSingleValue($a);
1891. $b = PHPExcel_Calculation_Functions:: flattenSingleValue($b);
1893. return (int) ($a == $b);
1894. } // function DELTA()
1897. /**
1898. * GESTEP
1899. *
1900. * Returns 1 if number = step; returns 0 (zero) otherwise
1901. *
1902. * @param float $number
1903. * @param float $step
1904. * @return int
1905. */
1906. public static function GESTEP($number, $step=0) {
1907. $number = PHPExcel_Calculation_Functions:: flattenSingleValue($number);
1908. $step = PHPExcel_Calculation_Functions:: flattenSingleValue($step);
1910. return (int) ($number >= $step);
1911. } // function GESTEP()
1914. //
1915. // Private method to calculate the erf value
1916. //
1917. private static $_two_sqrtpi = 1.128379167095512574;
1919. public static function _erfVal($x) {
1920. if ( abs($x) > 2.2) {
1921. return 1 - self::_erfcVal($x);
1922. }
1923. $sum = $term = $x;
1924. $xsqr = ($x * $x);
1925. $j = 1;
1926. do {
1927. $term *= $xsqr / $j;
1928. $sum -= $term / (2 * $j + 1);
1929. ++$j;
1930. $term *= $xsqr / $j;
1931. $sum += $term / (2 * $j + 1);
1932. ++$j;
1933. if ($sum == 0.0) {
1934. break;
1935. }
1936. } while ( abs($term / $sum) > PRECISION);
1937. return self::$_two_sqrtpi * $sum;
1938. } // function _erfVal()
1941. /**
1942. * ERF
1943. *
1944. * Returns the error function integrated between lower_limit and upper_limit
1945. *
1946. * @param float $lower lower bound for integrating ERF
1947. * @param float $upper upper bound for integrating ERF.
1948. * If omitted, ERF integrates between zero and lower_limit
1949. * @return int
1950. */
1951. public static function ERF($lower, $upper = null) {
1952. $lower = PHPExcel_Calculation_Functions:: flattenSingleValue($lower);
1953. $upper = PHPExcel_Calculation_Functions:: flattenSingleValue($upper);
1955. if ( is_numeric($lower)) {
1956. if ($lower < 0) {
1957. return PHPExcel_Calculation_Functions:: NaN();
1958. }
1959. if ( is_null($upper)) {
1960. return self::_erfVal($lower);
1961. }
1962. if ( is_numeric($upper)) {
1963. if ($upper < 0) {
1964. return PHPExcel_Calculation_Functions:: NaN();
1965. }
1966. return self::_erfVal($upper) - self::_erfVal($lower);
1967. }
1968. }
1969. return PHPExcel_Calculation_Functions:: VALUE();
1970. } // function ERF()
1973. //
1974. // Private method to calculate the erfc value
1975. //
1976. private static $_one_sqrtpi = 0.564189583547756287;
1978. private static function _erfcVal($x) {
1979. if ( abs($x) < 2.2) {
1980. return 1 - self::_erfVal($x);
1981. }
1982. if ($x < 0) {
1983. return 2 - self:: ERFC(-$x);
1984. }
1985. $a = $n = 1;
1986. $b = $c = $x;
1987. $d = ($x * $x) + 0.5;
1988. $q1 = $q2 = $b / $d;
1989. $t = 0;
1990. do {
1991. $t = $a * $n + $b * $x;
1992. $a = $b;
1993. $b = $t;
1994. $t = $c * $n + $d * $x;
1995. $c = $d;
1996. $d = $t;
1997. $n += 0.5;
1998. $q1 = $q2;
1999. $q2 = $b / $d;
2000. } while (( abs($q1 - $q2) / $q2) > PRECISION);
2001. return self::$_one_sqrtpi * exp(-$x * $x) * $q2;
2002. } // function _erfcVal()
2005. /**
2006. * ERFC
2007. *
2008. * Returns the complementary ERF function integrated between x and infinity
2009. *
2010. * @param float $x The lower bound for integrating ERF
2011. * @return int
2012. */
2013. public static function ERFC($x) {
2014. $x = PHPExcel_Calculation_Functions:: flattenSingleValue($x);
2016. if ( is_numeric($x)) {
2017. if ($x < 0) {
2018. return PHPExcel_Calculation_Functions:: NaN();
2019. }
2020. return self::_erfcVal($x);
2021. }
2022. return PHPExcel_Calculation_Functions:: VALUE();
2023. } // function ERFC()
2026. /**
2027. * getConversionGroups
2028. *
2029. * @return array
2030. */
2031. public static function getConversionGroups() {
2032. $conversionGroups = array();
2033. foreach(self::$_conversionUnits as $conversionUnit) {
2034. $conversionGroups[] = $conversionUnit['Group'];
2035. }
2036. return array_merge( array_unique($conversionGroups));
2037. } // function getConversionGroups()
2040. /**
2041. * getConversionGroupUnits
2042. *
2043. * @return array
2044. */
2045. public static function getConversionGroupUnits($group = NULL) {
2046. $conversionGroups = array();
2047. foreach(self::$_conversionUnits as $conversionUnit => $conversionGroup) {
2048. if ((is_null($group)) || ($conversionGroup['Group'] == $group)) {
2049. $conversionGroups[$conversionGroup['Group']][] = $conversionUnit;
2050. }
2051. }
2052. return $conversionGroups;
2053. } // function getConversionGroupUnits()
2056. /**
2057. * getConversionGroupUnitDetails
2058. *
2059. * @return array
2060. */
2061. public static function getConversionGroupUnitDetails($group = NULL) {
2062. $conversionGroups = array();
2063. foreach(self::$_conversionUnits as $conversionUnit => $conversionGroup) {
2064. if ((is_null($group)) || ($conversionGroup['Group'] == $group)) {
2065. $conversionGroups[$conversionGroup['Group']][] = array( 'unit' => $conversionUnit,
2066. 'description' => $conversionGroup['Unit Name']
2067. );
2068. }
2069. }
2070. return $conversionGroups;
2071. } // function getConversionGroupUnitDetails()
2074. /**
2075. * getConversionGroups
2076. *
2077. * @return array
2078. */
2079. public static function getConversionMultipliers() {
2080. return self::$_conversionMultipliers;
2081. } // function getConversionGroups()
2084. /**
2085. * CONVERTUOM
2086. *
2087. * @param float $value
2088. * @param string $fromUOM
2089. * @param string $toUOM
2090. * @return float
2091. */
2092. public static function CONVERTUOM($value, $fromUOM, $toUOM) {
2093. $value = PHPExcel_Calculation_Functions:: flattenSingleValue($value);
2094. $fromUOM = PHPExcel_Calculation_Functions:: flattenSingleValue($fromUOM);
2095. $toUOM = PHPExcel_Calculation_Functions:: flattenSingleValue($toUOM);
2097. if (! is_numeric($value)) {
2098. return PHPExcel_Calculation_Functions:: VALUE();
2099. }
2100. $fromMultiplier = 1;
2101. if (isset(self::$_conversionUnits[$fromUOM])) {
2102. $unitGroup1 = self::$_conversionUnits[$fromUOM]['Group'];
2103. } else {
2104. $fromMultiplier = substr($fromUOM,0,1);
2105. $fromUOM = substr($fromUOM,1);
2106. if (isset(self::$_conversionMultipliers[$fromMultiplier])) {
2107. $fromMultiplier = self::$_conversionMultipliers[$fromMultiplier]['multiplier'];
2108. } else {
2109. return PHPExcel_Calculation_Functions:: NA();
2110. }
2111. if ((isset(self::$_conversionUnits[$fromUOM])) && (self::$_conversionUnits[$fromUOM]['AllowPrefix'])) {
2112. $unitGroup1 = self::$_conversionUnits[$fromUOM]['Group'];
2113. } else {
2114. return PHPExcel_Calculation_Functions:: NA();
2115. }
2116. }
2117. $value *= $fromMultiplier;
2119. $toMultiplier = 1;
2120. if (isset(self::$_conversionUnits[$toUOM])) {
2121. $unitGroup2 = self::$_conversionUnits[$toUOM]['Group'];
2122. } else {
2123. $toMultiplier = substr($toUOM,0,1);
2124. $toUOM = substr($toUOM,1);
2125. if (isset(self::$_conversionMultipliers[$toMultiplier])) {
2126. $toMultiplier = self::$_conversionMultipliers[$toMultiplier]['multiplier'];
2127. } else {
2128. return PHPExcel_Calculation_Functions:: NA();
2129. }
2130. if ((isset(self::$_conversionUnits[$toUOM])) && (self::$_conversionUnits[$toUOM]['AllowPrefix'])) {
2131. $unitGroup2 = self::$_conversionUnits[$toUOM]['Group'];
2132. } else {
2133. return PHPExcel_Calculation_Functions:: NA();
2134. }
2135. }
2136. if ($unitGroup1 != $unitGroup2) {
2137. return PHPExcel_Calculation_Functions:: NA();
2138. }
2140. if ($fromUOM == $toUOM) {
2141. return 1.0;
2142. } elseif ($unitGroup1 == 'Temperature') {
2143. if (($fromUOM == 'F') || ($fromUOM == 'fah')) {
2144. if (($toUOM == 'F') || ($toUOM == 'fah')) {
2145. return 1.0;
2146. } else {
2147. $value = (($value - 32) / 1.8);
2148. if (($toUOM == 'K') || ($toUOM == 'kel')) {
2149. $value += 273.15;
2150. }
2151. return $value;
2152. }
2153. } elseif ((($fromUOM == 'K') || ($fromUOM == 'kel')) &&
2154. (($toUOM == 'K') || ($toUOM == 'kel'))) {
2155. return 1.0;
2156. } elseif ((($fromUOM == 'C') || ($fromUOM == 'cel')) &&
2157. (($toUOM == 'C') || ($toUOM == 'cel'))) {
2158. return 1.0;
2159. }
2160. if (($toUOM == 'F') || ($toUOM == 'fah')) {
2161. if (($fromUOM == 'K') || ($fromUOM == 'kel')) {
2162. $value -= 273.15;
2163. }
2164. return ($value * 1.8) + 32;
2165. }
2166. if (($toUOM == 'C') || ($toUOM == 'cel')) {
2167. return $value - 273.15;
2168. }
2169. return $value + 273.15;
2170. }
2171. return ($value * self::$_unitConversions[$unitGroup1][$fromUOM][$toUOM]) / $toMultiplier;
2172. } // function CONVERTUOM()
2174. } // class PHPExcel_Calculation_Engineering

Documentation generated on Sun, 27 Feb 2011 16:30:31 -0800 by phpDocumentor 1.4.3