Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

Engineering.php @ 1

Last change on this file since 1 was 1, checked in by dungnv, 11 years ago

File size: 96.1 KB

Line
1	<?php
2	/**
3	* PHPExcel
4	*
5	* Copyright (c) 2006 - 2014 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 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
24	* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
25	* @version 1.8.0, 2014-03-02
26	*/
27
28
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	}
37
38
39	/** EULER */
40	define('EULER', 2.71828182845904523536);
41
42
43	/**
44	* PHPExcel_Calculation_Engineering
45	*
46	* @category PHPExcel
47	* @package PHPExcel_Calculation
48	* @copyright Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
49	*/
50	class PHPExcel_Calculation_Engineering {
51
52	/**
53	* Details of the Units of measure that can be used in CONVERTUOM()
54	*
55	* @var mixed[]
56	*/
57	private static $_conversionUnits = array( 'g' => array( 'Group' => 'Mass', 'Unit Name' => 'Gram', 'AllowPrefix' => True ),
58	'sg' => array( 'Group' => 'Mass', 'Unit Name' => 'Slug', 'AllowPrefix' => False ),
59	'lbm' => array( 'Group' => 'Mass', 'Unit Name' => 'Pound mass (avoirdupois)', 'AllowPrefix' => False ),
60	'u' => array( 'Group' => 'Mass', 'Unit Name' => 'U (atomic mass unit)', 'AllowPrefix' => True ),
61	'ozm' => array( 'Group' => 'Mass', 'Unit Name' => 'Ounce mass (avoirdupois)', 'AllowPrefix' => False ),
62	'm' => array( 'Group' => 'Distance', 'Unit Name' => 'Meter', 'AllowPrefix' => True ),
63	'mi' => array( 'Group' => 'Distance', 'Unit Name' => 'Statute mile', 'AllowPrefix' => False ),
64	'Nmi' => array( 'Group' => 'Distance', 'Unit Name' => 'Nautical mile', 'AllowPrefix' => False ),
65	'in' => array( 'Group' => 'Distance', 'Unit Name' => 'Inch', 'AllowPrefix' => False ),
66	'ft' => array( 'Group' => 'Distance', 'Unit Name' => 'Foot', 'AllowPrefix' => False ),
67	'yd' => array( 'Group' => 'Distance', 'Unit Name' => 'Yard', 'AllowPrefix' => False ),
68	'ang' => array( 'Group' => 'Distance', 'Unit Name' => 'Angstrom', 'AllowPrefix' => True ),
69	'Pica' => array( 'Group' => 'Distance', 'Unit Name' => 'Pica (1/72 in)', 'AllowPrefix' => False ),
70	'yr' => array( 'Group' => 'Time', 'Unit Name' => 'Year', 'AllowPrefix' => False ),
71	'day' => array( 'Group' => 'Time', 'Unit Name' => 'Day', 'AllowPrefix' => False ),
72	'hr' => array( 'Group' => 'Time', 'Unit Name' => 'Hour', 'AllowPrefix' => False ),
73	'mn' => array( 'Group' => 'Time', 'Unit Name' => 'Minute', 'AllowPrefix' => False ),
74	'sec' => array( 'Group' => 'Time', 'Unit Name' => 'Second', 'AllowPrefix' => True ),
75	'Pa' => array( 'Group' => 'Pressure', 'Unit Name' => 'Pascal', 'AllowPrefix' => True ),
76	'p' => array( 'Group' => 'Pressure', 'Unit Name' => 'Pascal', 'AllowPrefix' => True ),
77	'atm' => array( 'Group' => 'Pressure', 'Unit Name' => 'Atmosphere', 'AllowPrefix' => True ),
78	'at' => array( 'Group' => 'Pressure', 'Unit Name' => 'Atmosphere', 'AllowPrefix' => True ),
79	'mmHg' => array( 'Group' => 'Pressure', 'Unit Name' => 'mm of Mercury', 'AllowPrefix' => True ),
80	'N' => array( 'Group' => 'Force', 'Unit Name' => 'Newton', 'AllowPrefix' => True ),
81	'dyn' => array( 'Group' => 'Force', 'Unit Name' => 'Dyne', 'AllowPrefix' => True ),
82	'dy' => array( 'Group' => 'Force', 'Unit Name' => 'Dyne', 'AllowPrefix' => True ),
83	'lbf' => array( 'Group' => 'Force', 'Unit Name' => 'Pound force', 'AllowPrefix' => False ),
84	'J' => array( 'Group' => 'Energy', 'Unit Name' => 'Joule', 'AllowPrefix' => True ),
85	'e' => array( 'Group' => 'Energy', 'Unit Name' => 'Erg', 'AllowPrefix' => True ),
86	'c' => array( 'Group' => 'Energy', 'Unit Name' => 'Thermodynamic calorie', 'AllowPrefix' => True ),
87	'cal' => array( 'Group' => 'Energy', 'Unit Name' => 'IT calorie', 'AllowPrefix' => True ),
88	'eV' => array( 'Group' => 'Energy', 'Unit Name' => 'Electron volt', 'AllowPrefix' => True ),
89	'ev' => array( 'Group' => 'Energy', 'Unit Name' => 'Electron volt', 'AllowPrefix' => True ),
90	'HPh' => array( 'Group' => 'Energy', 'Unit Name' => 'Horsepower-hour', 'AllowPrefix' => False ),
91	'hh' => array( 'Group' => 'Energy', 'Unit Name' => 'Horsepower-hour', 'AllowPrefix' => False ),
92	'Wh' => array( 'Group' => 'Energy', 'Unit Name' => 'Watt-hour', 'AllowPrefix' => True ),
93	'wh' => array( 'Group' => 'Energy', 'Unit Name' => 'Watt-hour', 'AllowPrefix' => True ),
94	'flb' => array( 'Group' => 'Energy', 'Unit Name' => 'Foot-pound', 'AllowPrefix' => False ),
95	'BTU' => array( 'Group' => 'Energy', 'Unit Name' => 'BTU', 'AllowPrefix' => False ),
96	'btu' => array( 'Group' => 'Energy', 'Unit Name' => 'BTU', 'AllowPrefix' => False ),
97	'HP' => array( 'Group' => 'Power', 'Unit Name' => 'Horsepower', 'AllowPrefix' => False ),
98	'h' => array( 'Group' => 'Power', 'Unit Name' => 'Horsepower', 'AllowPrefix' => False ),
99	'W' => array( 'Group' => 'Power', 'Unit Name' => 'Watt', 'AllowPrefix' => True ),
100	'w' => array( 'Group' => 'Power', 'Unit Name' => 'Watt', 'AllowPrefix' => True ),
101	'T' => array( 'Group' => 'Magnetism', 'Unit Name' => 'Tesla', 'AllowPrefix' => True ),
102	'ga' => array( 'Group' => 'Magnetism', 'Unit Name' => 'Gauss', 'AllowPrefix' => True ),
103	'C' => array( 'Group' => 'Temperature', 'Unit Name' => 'Celsius', 'AllowPrefix' => False ),
104	'cel' => array( 'Group' => 'Temperature', 'Unit Name' => 'Celsius', 'AllowPrefix' => False ),
105	'F' => array( 'Group' => 'Temperature', 'Unit Name' => 'Fahrenheit', 'AllowPrefix' => False ),
106	'fah' => array( 'Group' => 'Temperature', 'Unit Name' => 'Fahrenheit', 'AllowPrefix' => False ),
107	'K' => array( 'Group' => 'Temperature', 'Unit Name' => 'Kelvin', 'AllowPrefix' => False ),
108	'kel' => array( 'Group' => 'Temperature', 'Unit Name' => 'Kelvin', 'AllowPrefix' => False ),
109	'tsp' => array( 'Group' => 'Liquid', 'Unit Name' => 'Teaspoon', 'AllowPrefix' => False ),
110	'tbs' => array( 'Group' => 'Liquid', 'Unit Name' => 'Tablespoon', 'AllowPrefix' => False ),
111	'oz' => array( 'Group' => 'Liquid', 'Unit Name' => 'Fluid Ounce', 'AllowPrefix' => False ),
112	'cup' => array( 'Group' => 'Liquid', 'Unit Name' => 'Cup', 'AllowPrefix' => False ),
113	'pt' => array( 'Group' => 'Liquid', 'Unit Name' => 'U.S. Pint', 'AllowPrefix' => False ),
114	'us_pt' => array( 'Group' => 'Liquid', 'Unit Name' => 'U.S. Pint', 'AllowPrefix' => False ),
115	'uk_pt' => array( 'Group' => 'Liquid', 'Unit Name' => 'U.K. Pint', 'AllowPrefix' => False ),
116	'qt' => array( 'Group' => 'Liquid', 'Unit Name' => 'Quart', 'AllowPrefix' => False ),
117	'gal' => array( 'Group' => 'Liquid', 'Unit Name' => 'Gallon', 'AllowPrefix' => False ),
118	'l' => array( 'Group' => 'Liquid', 'Unit Name' => 'Litre', 'AllowPrefix' => True ),
119	'lt' => array( 'Group' => 'Liquid', 'Unit Name' => 'Litre', 'AllowPrefix' => True )
120	);
121
122	/**
123	* Details of the Multiplier prefixes that can be used with Units of Measure in CONVERTUOM()
124	*
125	* @var mixed[]
126	*/
127	private static $_conversionMultipliers = array( 'Y' => array( 'multiplier' => 1E24, 'name' => 'yotta' ),
128	'Z' => array( 'multiplier' => 1E21, 'name' => 'zetta' ),
129	'E' => array( 'multiplier' => 1E18, 'name' => 'exa' ),
130	'P' => array( 'multiplier' => 1E15, 'name' => 'peta' ),
131	'T' => array( 'multiplier' => 1E12, 'name' => 'tera' ),
132	'G' => array( 'multiplier' => 1E9, 'name' => 'giga' ),
133	'M' => array( 'multiplier' => 1E6, 'name' => 'mega' ),
134	'k' => array( 'multiplier' => 1E3, 'name' => 'kilo' ),
135	'h' => array( 'multiplier' => 1E2, 'name' => 'hecto' ),
136	'e' => array( 'multiplier' => 1E1, 'name' => 'deka' ),
137	'd' => array( 'multiplier' => 1E-1, 'name' => 'deci' ),
138	'c' => array( 'multiplier' => 1E-2, 'name' => 'centi' ),
139	'm' => array( 'multiplier' => 1E-3, 'name' => 'milli' ),
140	'u' => array( 'multiplier' => 1E-6, 'name' => 'micro' ),
141	'n' => array( 'multiplier' => 1E-9, 'name' => 'nano' ),
142	'p' => array( 'multiplier' => 1E-12, 'name' => 'pico' ),
143	'f' => array( 'multiplier' => 1E-15, 'name' => 'femto' ),
144	'a' => array( 'multiplier' => 1E-18, 'name' => 'atto' ),
145	'z' => array( 'multiplier' => 1E-21, 'name' => 'zepto' ),
146	'y' => array( 'multiplier' => 1E-24, 'name' => 'yocto' )
147	);
148
149	/**
150	* Details of the Units of measure conversion factors, organised by group
151	*
152	* @var mixed[]
153	*/
154	private static $_unitConversions = array( 'Mass' => array( 'g' => array( 'g' => 1.0,
155	'sg' => 6.85220500053478E-05,
156	'lbm' => 2.20462291469134E-03,
157	'u' => 6.02217000000000E+23,
158	'ozm' => 3.52739718003627E-02
159	),
160	'sg' => array( 'g' => 1.45938424189287E+04,
161	'sg' => 1.0,
162	'lbm' => 3.21739194101647E+01,
163	'u' => 8.78866000000000E+27,
164	'ozm' => 5.14782785944229E+02
165	),
166	'lbm' => array( 'g' => 4.5359230974881148E+02,
167	'sg' => 3.10810749306493E-02,
168	'lbm' => 1.0,
169	'u' => 2.73161000000000E+26,
170	'ozm' => 1.60000023429410E+01
171	),
172	'u' => array( 'g' => 1.66053100460465E-24,
173	'sg' => 1.13782988532950E-28,
174	'lbm' => 3.66084470330684E-27,
175	'u' => 1.0,
176	'ozm' => 5.85735238300524E-26
177	),
178	'ozm' => array( 'g' => 2.83495152079732E+01,
179	'sg' => 1.94256689870811E-03,
180	'lbm' => 6.24999908478882E-02,
181	'u' => 1.70725600000000E+25,
182	'ozm' => 1.0
183	)
184	),
185	'Distance' => array( 'm' => array( 'm' => 1.0,
186	'mi' => 6.21371192237334E-04,
187	'Nmi' => 5.39956803455724E-04,
188	'in' => 3.93700787401575E+01,
189	'ft' => 3.28083989501312E+00,
190	'yd' => 1.09361329797891E+00,
191	'ang' => 1.00000000000000E+10,
192	'Pica' => 2.83464566929116E+03
193	),
194	'mi' => array( 'm' => 1.60934400000000E+03,
195	'mi' => 1.0,
196	'Nmi' => 8.68976241900648E-01,
197	'in' => 6.33600000000000E+04,
198	'ft' => 5.28000000000000E+03,
199	'yd' => 1.76000000000000E+03,
200	'ang' => 1.60934400000000E+13,
201	'Pica' => 4.56191999999971E+06
202	),
203	'Nmi' => array( 'm' => 1.85200000000000E+03,
204	'mi' => 1.15077944802354E+00,
205	'Nmi' => 1.0,
206	'in' => 7.29133858267717E+04,
207	'ft' => 6.07611548556430E+03,
208	'yd' => 2.02537182785694E+03,
209	'ang' => 1.85200000000000E+13,
210	'Pica' => 5.24976377952723E+06
211	),
212	'in' => array( 'm' => 2.54000000000000E-02,
213	'mi' => 1.57828282828283E-05,
214	'Nmi' => 1.37149028077754E-05,
215	'in' => 1.0,
216	'ft' => 8.33333333333333E-02,
217	'yd' => 2.77777777686643E-02,
218	'ang' => 2.54000000000000E+08,
219	'Pica' => 7.19999999999955E+01
220	),
221	'ft' => array( 'm' => 3.04800000000000E-01,
222	'mi' => 1.89393939393939E-04,
223	'Nmi' => 1.64578833693305E-04,
224	'in' => 1.20000000000000E+01,
225	'ft' => 1.0,
226	'yd' => 3.33333333223972E-01,
227	'ang' => 3.04800000000000E+09,
228	'Pica' => 8.63999999999946E+02
229	),
230	'yd' => array( 'm' => 9.14400000300000E-01,
231	'mi' => 5.68181818368230E-04,
232	'Nmi' => 4.93736501241901E-04,
233	'in' => 3.60000000118110E+01,
234	'ft' => 3.00000000000000E+00,
235	'yd' => 1.0,
236	'ang' => 9.14400000300000E+09,
237	'Pica' => 2.59200000085023E+03
238	),
239	'ang' => array( 'm' => 1.00000000000000E-10,
240	'mi' => 6.21371192237334E-14,
241	'Nmi' => 5.39956803455724E-14,
242	'in' => 3.93700787401575E-09,
243	'ft' => 3.28083989501312E-10,
244	'yd' => 1.09361329797891E-10,
245	'ang' => 1.0,
246	'Pica' => 2.83464566929116E-07
247	),
248	'Pica' => array( 'm' => 3.52777777777800E-04,
249	'mi' => 2.19205948372629E-07,
250	'Nmi' => 1.90484761219114E-07,
251	'in' => 1.38888888888898E-02,
252	'ft' => 1.15740740740748E-03,
253	'yd' => 3.85802469009251E-04,
254	'ang' => 3.52777777777800E+06,
255	'Pica' => 1.0
256	)
257	),
258	'Time' => array( 'yr' => array( 'yr' => 1.0,
259	'day' => 365.25,
260	'hr' => 8766.0,
261	'mn' => 525960.0,
262	'sec' => 31557600.0
263	),
264	'day' => array( 'yr' => 2.73785078713210E-03,
265	'day' => 1.0,
266	'hr' => 24.0,
267	'mn' => 1440.0,
268	'sec' => 86400.0
269	),
270	'hr' => array( 'yr' => 1.14077116130504E-04,
271	'day' => 4.16666666666667E-02,
272	'hr' => 1.0,
273	'mn' => 60.0,
274	'sec' => 3600.0
275	),
276	'mn' => array( 'yr' => 1.90128526884174E-06,
277	'day' => 6.94444444444444E-04,
278	'hr' => 1.66666666666667E-02,
279	'mn' => 1.0,
280	'sec' => 60.0
281	),
282	'sec' => array( 'yr' => 3.16880878140289E-08,
283	'day' => 1.15740740740741E-05,
284	'hr' => 2.77777777777778E-04,
285	'mn' => 1.66666666666667E-02,
286	'sec' => 1.0
287	)
288	),
289	'Pressure' => array( 'Pa' => array( 'Pa' => 1.0,
290	'p' => 1.0,
291	'atm' => 9.86923299998193E-06,
292	'at' => 9.86923299998193E-06,
293	'mmHg' => 7.50061707998627E-03
294	),
295	'p' => array( 'Pa' => 1.0,
296	'p' => 1.0,
297	'atm' => 9.86923299998193E-06,
298	'at' => 9.86923299998193E-06,
299	'mmHg' => 7.50061707998627E-03
300	),
301	'atm' => array( 'Pa' => 1.01324996583000E+05,
302	'p' => 1.01324996583000E+05,
303	'atm' => 1.0,
304	'at' => 1.0,
305	'mmHg' => 760.0
306	),
307	'at' => array( 'Pa' => 1.01324996583000E+05,
308	'p' => 1.01324996583000E+05,
309	'atm' => 1.0,
310	'at' => 1.0,
311	'mmHg' => 760.0
312	),
313	'mmHg' => array( 'Pa' => 1.33322363925000E+02,
314	'p' => 1.33322363925000E+02,
315	'atm' => 1.31578947368421E-03,
316	'at' => 1.31578947368421E-03,
317	'mmHg' => 1.0
318	)
319	),
320	'Force' => array( 'N' => array( 'N' => 1.0,
321	'dyn' => 1.0E+5,
322	'dy' => 1.0E+5,
323	'lbf' => 2.24808923655339E-01
324	),
325	'dyn' => array( 'N' => 1.0E-5,
326	'dyn' => 1.0,
327	'dy' => 1.0,
328	'lbf' => 2.24808923655339E-06
329	),
330	'dy' => array( 'N' => 1.0E-5,
331	'dyn' => 1.0,
332	'dy' => 1.0,
333	'lbf' => 2.24808923655339E-06
334	),
335	'lbf' => array( 'N' => 4.448222,
336	'dyn' => 4.448222E+5,
337	'dy' => 4.448222E+5,
338	'lbf' => 1.0
339	)
340	),
341	'Energy' => array( 'J' => array( 'J' => 1.0,
342	'e' => 9.99999519343231E+06,
343	'c' => 2.39006249473467E-01,
344	'cal' => 2.38846190642017E-01,
345	'eV' => 6.24145700000000E+18,
346	'ev' => 6.24145700000000E+18,
347	'HPh' => 3.72506430801000E-07,
348	'hh' => 3.72506430801000E-07,
349	'Wh' => 2.77777916238711E-04,
350	'wh' => 2.77777916238711E-04,
351	'flb' => 2.37304222192651E+01,
352	'BTU' => 9.47815067349015E-04,
353	'btu' => 9.47815067349015E-04
354	),
355	'e' => array( 'J' => 1.00000048065700E-07,
356	'e' => 1.0,
357	'c' => 2.39006364353494E-08,
358	'cal' => 2.38846305445111E-08,
359	'eV' => 6.24146000000000E+11,
360	'ev' => 6.24146000000000E+11,
361	'HPh' => 3.72506609848824E-14,
362	'hh' => 3.72506609848824E-14,
363	'Wh' => 2.77778049754611E-11,
364	'wh' => 2.77778049754611E-11,
365	'flb' => 2.37304336254586E-06,
366	'BTU' => 9.47815522922962E-11,
367	'btu' => 9.47815522922962E-11
368	),
369	'c' => array( 'J' => 4.18399101363672E+00,
370	'e' => 4.18398900257312E+07,
371	'c' => 1.0,
372	'cal' => 9.99330315287563E-01,
373	'eV' => 2.61142000000000E+19,
374	'ev' => 2.61142000000000E+19,
375	'HPh' => 1.55856355899327E-06,
376	'hh' => 1.55856355899327E-06,
377	'Wh' => 1.16222030532950E-03,
378	'wh' => 1.16222030532950E-03,
379	'flb' => 9.92878733152102E+01,
380	'BTU' => 3.96564972437776E-03,
381	'btu' => 3.96564972437776E-03
382	),
383	'cal' => array( 'J' => 4.18679484613929E+00,
384	'e' => 4.18679283372801E+07,
385	'c' => 1.00067013349059E+00,
386	'cal' => 1.0,
387	'eV' => 2.61317000000000E+19,
388	'ev' => 2.61317000000000E+19,
389	'HPh' => 1.55960800463137E-06,
390	'hh' => 1.55960800463137E-06,
391	'Wh' => 1.16299914807955E-03,
392	'wh' => 1.16299914807955E-03,
393	'flb' => 9.93544094443283E+01,
394	'BTU' => 3.96830723907002E-03,
395	'btu' => 3.96830723907002E-03
396	),
397	'eV' => array( 'J' => 1.60219000146921E-19,
398	'e' => 1.60218923136574E-12,
399	'c' => 3.82933423195043E-20,
400	'cal' => 3.82676978535648E-20,
401	'eV' => 1.0,
402	'ev' => 1.0,
403	'HPh' => 5.96826078912344E-26,
404	'hh' => 5.96826078912344E-26,
405	'Wh' => 4.45053000026614E-23,
406	'wh' => 4.45053000026614E-23,
407	'flb' => 3.80206452103492E-18,
408	'BTU' => 1.51857982414846E-22,
409	'btu' => 1.51857982414846E-22
410	),
411	'ev' => array( 'J' => 1.60219000146921E-19,
412	'e' => 1.60218923136574E-12,
413	'c' => 3.82933423195043E-20,
414	'cal' => 3.82676978535648E-20,
415	'eV' => 1.0,
416	'ev' => 1.0,
417	'HPh' => 5.96826078912344E-26,
418	'hh' => 5.96826078912344E-26,
419	'Wh' => 4.45053000026614E-23,
420	'wh' => 4.45053000026614E-23,
421	'flb' => 3.80206452103492E-18,
422	'BTU' => 1.51857982414846E-22,
423	'btu' => 1.51857982414846E-22
424	),
425	'HPh' => array( 'J' => 2.68451741316170E+06,
426	'e' => 2.68451612283024E+13,
427	'c' => 6.41616438565991E+05,
428	'cal' => 6.41186757845835E+05,
429	'eV' => 1.67553000000000E+25,
430	'ev' => 1.67553000000000E+25,
431	'HPh' => 1.0,
432	'hh' => 1.0,
433	'Wh' => 7.45699653134593E+02,
434	'wh' => 7.45699653134593E+02,
435	'flb' => 6.37047316692964E+07,
436	'BTU' => 2.54442605275546E+03,
437	'btu' => 2.54442605275546E+03
438	),
439	'hh' => array( 'J' => 2.68451741316170E+06,
440	'e' => 2.68451612283024E+13,
441	'c' => 6.41616438565991E+05,
442	'cal' => 6.41186757845835E+05,
443	'eV' => 1.67553000000000E+25,
444	'ev' => 1.67553000000000E+25,
445	'HPh' => 1.0,
446	'hh' => 1.0,
447	'Wh' => 7.45699653134593E+02,
448	'wh' => 7.45699653134593E+02,
449	'flb' => 6.37047316692964E+07,
450	'BTU' => 2.54442605275546E+03,
451	'btu' => 2.54442605275546E+03
452	),
453	'Wh' => array( 'J' => 3.59999820554720E+03,
454	'e' => 3.59999647518369E+10,
455	'c' => 8.60422069219046E+02,
456	'cal' => 8.59845857713046E+02,
457	'eV' => 2.24692340000000E+22,
458	'ev' => 2.24692340000000E+22,
459	'HPh' => 1.34102248243839E-03,
460	'hh' => 1.34102248243839E-03,
461	'Wh' => 1.0,
462	'wh' => 1.0,
463	'flb' => 8.54294774062316E+04,
464	'BTU' => 3.41213254164705E+00,
465	'btu' => 3.41213254164705E+00
466	),
467	'wh' => array( 'J' => 3.59999820554720E+03,
468	'e' => 3.59999647518369E+10,
469	'c' => 8.60422069219046E+02,
470	'cal' => 8.59845857713046E+02,
471	'eV' => 2.24692340000000E+22,
472	'ev' => 2.24692340000000E+22,
473	'HPh' => 1.34102248243839E-03,
474	'hh' => 1.34102248243839E-03,
475	'Wh' => 1.0,
476	'wh' => 1.0,
477	'flb' => 8.54294774062316E+04,
478	'BTU' => 3.41213254164705E+00,
479	'btu' => 3.41213254164705E+00
480	),
481	'flb' => array( 'J' => 4.21400003236424E-02,
482	'e' => 4.21399800687660E+05,
483	'c' => 1.00717234301644E-02,
484	'cal' => 1.00649785509554E-02,
485	'eV' => 2.63015000000000E+17,
486	'ev' => 2.63015000000000E+17,
487	'HPh' => 1.56974211145130E-08,
488	'hh' => 1.56974211145130E-08,
489	'Wh' => 1.17055614802000E-05,
490	'wh' => 1.17055614802000E-05,
491	'flb' => 1.0,
492	'BTU' => 3.99409272448406E-05,
493	'btu' => 3.99409272448406E-05
494	),
495	'BTU' => array( 'J' => 1.05505813786749E+03,
496	'e' => 1.05505763074665E+10,
497	'c' => 2.52165488508168E+02,
498	'cal' => 2.51996617135510E+02,
499	'eV' => 6.58510000000000E+21,
500	'ev' => 6.58510000000000E+21,
501	'HPh' => 3.93015941224568E-04,
502	'hh' => 3.93015941224568E-04,
503	'Wh' => 2.93071851047526E-01,
504	'wh' => 2.93071851047526E-01,
505	'flb' => 2.50369750774671E+04,
506	'BTU' => 1.0,
507	'btu' => 1.0,
508	),
509	'btu' => array( 'J' => 1.05505813786749E+03,
510	'e' => 1.05505763074665E+10,
511	'c' => 2.52165488508168E+02,
512	'cal' => 2.51996617135510E+02,
513	'eV' => 6.58510000000000E+21,
514	'ev' => 6.58510000000000E+21,
515	'HPh' => 3.93015941224568E-04,
516	'hh' => 3.93015941224568E-04,
517	'Wh' => 2.93071851047526E-01,
518	'wh' => 2.93071851047526E-01,
519	'flb' => 2.50369750774671E+04,
520	'BTU' => 1.0,
521	'btu' => 1.0,
522	)
523	),
524	'Power' => array( 'HP' => array( 'HP' => 1.0,
525	'h' => 1.0,
526	'W' => 7.45701000000000E+02,
527	'w' => 7.45701000000000E+02
528	),
529	'h' => array( 'HP' => 1.0,
530	'h' => 1.0,
531	'W' => 7.45701000000000E+02,
532	'w' => 7.45701000000000E+02
533	),
534	'W' => array( 'HP' => 1.34102006031908E-03,
535	'h' => 1.34102006031908E-03,
536	'W' => 1.0,
537	'w' => 1.0
538	),
539	'w' => array( 'HP' => 1.34102006031908E-03,
540	'h' => 1.34102006031908E-03,
541	'W' => 1.0,
542	'w' => 1.0
543	)
544	),
545	'Magnetism' => array( 'T' => array( 'T' => 1.0,
546	'ga' => 10000.0
547	),
548	'ga' => array( 'T' => 0.0001,
549	'ga' => 1.0
550	)
551	),
552	'Liquid' => array( 'tsp' => array( 'tsp' => 1.0,
553	'tbs' => 3.33333333333333E-01,
554	'oz' => 1.66666666666667E-01,
555	'cup' => 2.08333333333333E-02,
556	'pt' => 1.04166666666667E-02,
557	'us_pt' => 1.04166666666667E-02,
558	'uk_pt' => 8.67558516821960E-03,
559	'qt' => 5.20833333333333E-03,
560	'gal' => 1.30208333333333E-03,
561	'l' => 4.92999408400710E-03,
562	'lt' => 4.92999408400710E-03
563	),
564	'tbs' => array( 'tsp' => 3.00000000000000E+00,
565	'tbs' => 1.0,
566	'oz' => 5.00000000000000E-01,
567	'cup' => 6.25000000000000E-02,
568	'pt' => 3.12500000000000E-02,
569	'us_pt' => 3.12500000000000E-02,
570	'uk_pt' => 2.60267555046588E-02,
571	'qt' => 1.56250000000000E-02,
572	'gal' => 3.90625000000000E-03,
573	'l' => 1.47899822520213E-02,
574	'lt' => 1.47899822520213E-02
575	),
576	'oz' => array( 'tsp' => 6.00000000000000E+00,
577	'tbs' => 2.00000000000000E+00,
578	'oz' => 1.0,
579	'cup' => 1.25000000000000E-01,
580	'pt' => 6.25000000000000E-02,
581	'us_pt' => 6.25000000000000E-02,
582	'uk_pt' => 5.20535110093176E-02,
583	'qt' => 3.12500000000000E-02,
584	'gal' => 7.81250000000000E-03,
585	'l' => 2.95799645040426E-02,
586	'lt' => 2.95799645040426E-02
587	),
588	'cup' => array( 'tsp' => 4.80000000000000E+01,
589	'tbs' => 1.60000000000000E+01,
590	'oz' => 8.00000000000000E+00,
591	'cup' => 1.0,
592	'pt' => 5.00000000000000E-01,
593	'us_pt' => 5.00000000000000E-01,
594	'uk_pt' => 4.16428088074541E-01,
595	'qt' => 2.50000000000000E-01,
596	'gal' => 6.25000000000000E-02,
597	'l' => 2.36639716032341E-01,
598	'lt' => 2.36639716032341E-01
599	),
600	'pt' => array( 'tsp' => 9.60000000000000E+01,
601	'tbs' => 3.20000000000000E+01,
602	'oz' => 1.60000000000000E+01,
603	'cup' => 2.00000000000000E+00,
604	'pt' => 1.0,
605	'us_pt' => 1.0,
606	'uk_pt' => 8.32856176149081E-01,
607	'qt' => 5.00000000000000E-01,
608	'gal' => 1.25000000000000E-01,
609	'l' => 4.73279432064682E-01,
610	'lt' => 4.73279432064682E-01
611	),
612	'us_pt' => array( 'tsp' => 9.60000000000000E+01,
613	'tbs' => 3.20000000000000E+01,
614	'oz' => 1.60000000000000E+01,
615	'cup' => 2.00000000000000E+00,
616	'pt' => 1.0,
617	'us_pt' => 1.0,
618	'uk_pt' => 8.32856176149081E-01,
619	'qt' => 5.00000000000000E-01,
620	'gal' => 1.25000000000000E-01,
621	'l' => 4.73279432064682E-01,
622	'lt' => 4.73279432064682E-01
623	),
624	'uk_pt' => array( 'tsp' => 1.15266000000000E+02,
625	'tbs' => 3.84220000000000E+01,
626	'oz' => 1.92110000000000E+01,
627	'cup' => 2.40137500000000E+00,
628	'pt' => 1.20068750000000E+00,
629	'us_pt' => 1.20068750000000E+00,
630	'uk_pt' => 1.0,
631	'qt' => 6.00343750000000E-01,
632	'gal' => 1.50085937500000E-01,
633	'l' => 5.68260698087162E-01,
634	'lt' => 5.68260698087162E-01
635	),
636	'qt' => array( 'tsp' => 1.92000000000000E+02,
637	'tbs' => 6.40000000000000E+01,
638	'oz' => 3.20000000000000E+01,
639	'cup' => 4.00000000000000E+00,
640	'pt' => 2.00000000000000E+00,
641	'us_pt' => 2.00000000000000E+00,
642	'uk_pt' => 1.66571235229816E+00,
643	'qt' => 1.0,
644	'gal' => 2.50000000000000E-01,
645	'l' => 9.46558864129363E-01,
646	'lt' => 9.46558864129363E-01
647	),
648	'gal' => array( 'tsp' => 7.68000000000000E+02,
649	'tbs' => 2.56000000000000E+02,
650	'oz' => 1.28000000000000E+02,
651	'cup' => 1.60000000000000E+01,
652	'pt' => 8.00000000000000E+00,
653	'us_pt' => 8.00000000000000E+00,
654	'uk_pt' => 6.66284940919265E+00,
655	'qt' => 4.00000000000000E+00,
656	'gal' => 1.0,
657	'l' => 3.78623545651745E+00,
658	'lt' => 3.78623545651745E+00
659	),
660	'l' => array( 'tsp' => 2.02840000000000E+02,
661	'tbs' => 6.76133333333333E+01,
662	'oz' => 3.38066666666667E+01,
663	'cup' => 4.22583333333333E+00,
664	'pt' => 2.11291666666667E+00,
665	'us_pt' => 2.11291666666667E+00,
666	'uk_pt' => 1.75975569552166E+00,
667	'qt' => 1.05645833333333E+00,
668	'gal' => 2.64114583333333E-01,
669	'l' => 1.0,
670	'lt' => 1.0
671	),
672	'lt' => array( 'tsp' => 2.02840000000000E+02,
673	'tbs' => 6.76133333333333E+01,
674	'oz' => 3.38066666666667E+01,
675	'cup' => 4.22583333333333E+00,
676	'pt' => 2.11291666666667E+00,
677	'us_pt' => 2.11291666666667E+00,
678	'uk_pt' => 1.75975569552166E+00,
679	'qt' => 1.05645833333333E+00,
680	'gal' => 2.64114583333333E-01,
681	'l' => 1.0,
682	'lt' => 1.0
683	)
684	)
685	);
686
687
688	/**
689	* _parseComplex
690	*
691	* Parses a complex number into its real and imaginary parts, and an I or J suffix
692	*
693	* @param string $complexNumber The complex number
694	* @return string[] Indexed on "real", "imaginary" and "suffix"
695	*/
696	public static function _parseComplex($complexNumber) {
697	$workString = (string) $complexNumber;
698
699	$realNumber = $imaginary = 0;
700	// Extract the suffix, if there is one
701	$suffix = substr($workString,-1);
702	if (!is_numeric($suffix)) {
703	$workString = substr($workString,0,-1);
704	} else {
705	$suffix = '';
706	}
707
708	// Split the input into its Real and Imaginary components
709	$leadingSign = 0;
710	if (strlen($workString) > 0) {
711	$leadingSign = (($workString{0} == '+') \|\| ($workString{0} == '-')) ? 1 : 0;
712	}
713	$power = '';
714	$realNumber = strtok($workString, '+-');
715	if (strtoupper(substr($realNumber,-1)) == 'E') {
716	$power = strtok('+-');
717	++$leadingSign;
718	}
719
720	$realNumber = substr($workString,0,strlen($realNumber)+strlen($power)+$leadingSign);
721
722	if ($suffix != '') {
723	$imaginary = substr($workString,strlen($realNumber));
724
725	if (($imaginary == '') && (($realNumber == '') \|\| ($realNumber == '+') \|\| ($realNumber == '-'))) {
726	$imaginary = $realNumber.'1';
727	$realNumber = '0';
728	} else if ($imaginary == '') {
729	$imaginary = $realNumber;
730	$realNumber = '0';
731	} elseif (($imaginary == '+') \|\| ($imaginary == '-')) {
732	$imaginary .= '1';
733	}
734	}
735
736	return array( 'real' => $realNumber,
737	'imaginary' => $imaginary,
738	'suffix' => $suffix
739	);
740	} // function _parseComplex()
741
742
743	/**
744	* Cleans the leading characters in a complex number string
745	*
746	* @param string $complexNumber The complex number to clean
747	* @return string The "cleaned" complex number
748	*/
749	private static function _cleanComplex($complexNumber) {
750	if ($complexNumber{0} == '+') $complexNumber = substr($complexNumber,1);
751	if ($complexNumber{0} == '0') $complexNumber = substr($complexNumber,1);
752	if ($complexNumber{0} == '.') $complexNumber = '0'.$complexNumber;
753	if ($complexNumber{0} == '+') $complexNumber = substr($complexNumber,1);
754	return $complexNumber;
755	}
756
757	/**
758	* Formats a number base string value with leading zeroes
759	*
760	* @param string $xVal The "number" to pad
761	* @param integer $places The length that we want to pad this value
762	* @return string The padded "number"
763	*/
764	private static function _nbrConversionFormat($xVal, $places) {
765	if (!is_null($places)) {
766	if (strlen($xVal) <= $places) {
767	return substr(str_pad($xVal, $places, '0', STR_PAD_LEFT), -10);
768	} else {
769	return PHPExcel_Calculation_Functions::NaN();
770	}
771	}
772
773	return substr($xVal, -10);
774	} // function _nbrConversionFormat()
775
776	/**
777	* BESSELI
778	*
779	* Returns the modified Bessel function In(x), which is equivalent to the Bessel function evaluated
780	* for purely imaginary arguments
781	*
782	* Excel Function:
783	* BESSELI(x,ord)
784	*
785	* @access public
786	* @category Engineering Functions
787	* @param float $x The value at which to evaluate the function.
788	* If x is nonnumeric, BESSELI returns the #VALUE! error value.
789	* @param integer $ord The order of the Bessel function.
790	* If ord is not an integer, it is truncated.
791	* If $ord is nonnumeric, BESSELI returns the #VALUE! error value.
792	* If $ord < 0, BESSELI returns the #NUM! error value.
793	* @return float
794	*
795	*/
796	public static function BESSELI($x, $ord) {
797	$x = (is_null($x)) ? 0.0 : PHPExcel_Calculation_Functions::flattenSingleValue($x);
798	$ord = (is_null($ord)) ? 0.0 : PHPExcel_Calculation_Functions::flattenSingleValue($ord);
799
800	if ((is_numeric($x)) && (is_numeric($ord))) {
801	$ord = floor($ord);
802	if ($ord < 0) {
803	return PHPExcel_Calculation_Functions::NaN();
804	}
805
806	if (abs($x) <= 30) {
807	$fResult = $fTerm = pow($x / 2, $ord) / PHPExcel_Calculation_MathTrig::FACT($ord);
808	$ordK = 1;
809	$fSqrX = ($x * $x) / 4;
810	do {
811	$fTerm *= $fSqrX;
812	$fTerm /= ($ordK * ($ordK + $ord));
813	$fResult += $fTerm;
814	} while ((abs($fTerm) > 1e-12) && (++$ordK < 100));
815	} else {
816	$f_2_PI = 2 * M_PI;
817
818	$fXAbs = abs($x);
819	$fResult = exp($fXAbs) / sqrt($f_2_PI * $fXAbs);
820	if (($ord & 1) && ($x < 0)) {
821	$fResult = -$fResult;
822	}
823	}
824	return (is_nan($fResult)) ? PHPExcel_Calculation_Functions::NaN() : $fResult;
825	}
826	return PHPExcel_Calculation_Functions::VALUE();
827	} // function BESSELI()
828
829
830	/**
831	* BESSELJ
832	*
833	* Returns the Bessel function
834	*
835	* Excel Function:
836	* BESSELJ(x,ord)
837	*
838	* @access public
839	* @category Engineering Functions
840	* @param float $x The value at which to evaluate the function.
841	* If x is nonnumeric, BESSELJ returns the #VALUE! error value.
842	* @param integer $ord The order of the Bessel function. If n is not an integer, it is truncated.
843	* If $ord is nonnumeric, BESSELJ returns the #VALUE! error value.
844	* If $ord < 0, BESSELJ returns the #NUM! error value.
845	* @return float
846	*
847	*/
848	public static function BESSELJ($x, $ord) {
849	$x = (is_null($x)) ? 0.0 : PHPExcel_Calculation_Functions::flattenSingleValue($x);
850	$ord = (is_null($ord)) ? 0.0 : PHPExcel_Calculation_Functions::flattenSingleValue($ord);
851
852	if ((is_numeric($x)) && (is_numeric($ord))) {
853	$ord = floor($ord);
854	if ($ord < 0) {
855	return PHPExcel_Calculation_Functions::NaN();
856	}
857
858	$fResult = 0;
859	if (abs($x) <= 30) {
860	$fResult = $fTerm = pow($x / 2, $ord) / PHPExcel_Calculation_MathTrig::FACT($ord);
861	$ordK = 1;
862	$fSqrX = ($x * $x) / -4;
863	do {
864	$fTerm *= $fSqrX;
865	$fTerm /= ($ordK * ($ordK + $ord));
866	$fResult += $fTerm;
867	} while ((abs($fTerm) > 1e-12) && (++$ordK < 100));
868	} else {
869	$f_PI_DIV_2 = M_PI / 2;
870	$f_PI_DIV_4 = M_PI / 4;
871
872	$fXAbs = abs($x);
873	$fResult = sqrt(M_2DIVPI / $fXAbs) * cos($fXAbs - $ord * $f_PI_DIV_2 - $f_PI_DIV_4);
874	if (($ord & 1) && ($x < 0)) {
875	$fResult = -$fResult;
876	}
877	}
878	return (is_nan($fResult)) ? PHPExcel_Calculation_Functions::NaN() : $fResult;
879	}
880	return PHPExcel_Calculation_Functions::VALUE();
881	} // function BESSELJ()
882
883
884	private static function _Besselk0($fNum) {
885	if ($fNum <= 2) {
886	$fNum2 = $fNum * 0.5;
887	$y = ($fNum2 * $fNum2);
888	$fRet = -log($fNum2) * self::BESSELI($fNum, 0) +
889	(-0.57721566 + $y * (0.42278420 + $y * (0.23069756 + $y * (0.3488590e-1 + $y * (0.262698e-2 + $y *
890	(0.10750e-3 + $y * 0.74e-5))))));
891	} else {
892	$y = 2 / $fNum;
893	$fRet = exp(-$fNum) / sqrt($fNum) *
894	(1.25331414 + $y * (-0.7832358e-1 + $y * (0.2189568e-1 + $y * (-0.1062446e-1 + $y *
895	(0.587872e-2 + $y * (-0.251540e-2 + $y * 0.53208e-3))))));
896	}
897	return $fRet;
898	} // function _Besselk0()
899
900
901	private static function _Besselk1($fNum) {
902	if ($fNum <= 2) {
903	$fNum2 = $fNum * 0.5;
904	$y = ($fNum2 * $fNum2);
905	$fRet = log($fNum2) * self::BESSELI($fNum, 1) +
906	(1 + $y * (0.15443144 + $y * (-0.67278579 + $y * (-0.18156897 + $y * (-0.1919402e-1 + $y *
907	(-0.110404e-2 + $y * (-0.4686e-4))))))) / $fNum;
908	} else {
909	$y = 2 / $fNum;
910	$fRet = exp(-$fNum) / sqrt($fNum) *
911	(1.25331414 + $y * (0.23498619 + $y * (-0.3655620e-1 + $y * (0.1504268e-1 + $y * (-0.780353e-2 + $y *
912	(0.325614e-2 + $y * (-0.68245e-3)))))));
913	}
914	return $fRet;
915	} // function _Besselk1()
916
917
918	/**
919	* BESSELK
920	*
921	* Returns the modified Bessel function Kn(x), which is equivalent to the Bessel functions evaluated
922	* for purely imaginary arguments.
923	*
924	* Excel Function:
925	* BESSELK(x,ord)
926	*
927	* @access public
928	* @category Engineering Functions
929	* @param float $x The value at which to evaluate the function.
930	* If x is nonnumeric, BESSELK returns the #VALUE! error value.
931	* @param integer $ord The order of the Bessel function. If n is not an integer, it is truncated.
932	* If $ord is nonnumeric, BESSELK returns the #VALUE! error value.
933	* If $ord < 0, BESSELK returns the #NUM! error value.
934	* @return float
935	*
936	*/
937	public static function BESSELK($x, $ord) {
938	$x = (is_null($x)) ? 0.0 : PHPExcel_Calculation_Functions::flattenSingleValue($x);
939	$ord = (is_null($ord)) ? 0.0 : PHPExcel_Calculation_Functions::flattenSingleValue($ord);
940
941	if ((is_numeric($x)) && (is_numeric($ord))) {
942	if (($ord < 0) \|\| ($x == 0.0)) {
943	return PHPExcel_Calculation_Functions::NaN();
944	}
945
946	switch(floor($ord)) {
947	case 0 : return self::_Besselk0($x);
948	break;
949	case 1 : return self::_Besselk1($x);
950	break;
951	default : $fTox = 2 / $x;
952	$fBkm = self::_Besselk0($x);
953	$fBk = self::_Besselk1($x);
954	for ($n = 1; $n < $ord; ++$n) {
955	$fBkp = $fBkm + $n * $fTox * $fBk;
956	$fBkm = $fBk;
957	$fBk = $fBkp;
958	}
959	}
960	return (is_nan($fBk)) ? PHPExcel_Calculation_Functions::NaN() : $fBk;
961	}
962	return PHPExcel_Calculation_Functions::VALUE();
963	} // function BESSELK()
964
965
966	private static function _Bessely0($fNum) {
967	if ($fNum < 8.0) {
968	$y = ($fNum * $fNum);
969	$f1 = -2957821389.0 + $y * (7062834065.0 + $y * (-512359803.6 + $y * (10879881.29 + $y * (-86327.92757 + $y * 228.4622733))));
970	$f2 = 40076544269.0 + $y * (745249964.8 + $y * (7189466.438 + $y * (47447.26470 + $y * (226.1030244 + $y))));
971	$fRet = $f1 / $f2 + 0.636619772 * self::BESSELJ($fNum, 0) * log($fNum);
972	} else {
973	$z = 8.0 / $fNum;
974	$y = ($z * $z);
975	$xx = $fNum - 0.785398164;
976	$f1 = 1 + $y * (-0.1098628627e-2 + $y * (0.2734510407e-4 + $y * (-0.2073370639e-5 + $y * 0.2093887211e-6)));
977	$f2 = -0.1562499995e-1 + $y * (0.1430488765e-3 + $y * (-0.6911147651e-5 + $y * (0.7621095161e-6 + $y * (-0.934945152e-7))));
978	$fRet = sqrt(0.636619772 / $fNum) * (sin($xx) * $f1 + $z * cos($xx) * $f2);
979	}
980	return $fRet;
981	} // function _Bessely0()
982
983
984	private static function _Bessely1($fNum) {
985	if ($fNum < 8.0) {
986	$y = ($fNum * $fNum);
987	$f1 = $fNum * (-0.4900604943e13 + $y * (0.1275274390e13 + $y * (-0.5153438139e11 + $y * (0.7349264551e9 + $y *
988	(-0.4237922726e7 + $y * 0.8511937935e4)))));
989	$f2 = 0.2499580570e14 + $y * (0.4244419664e12 + $y * (0.3733650367e10 + $y * (0.2245904002e8 + $y *
990	(0.1020426050e6 + $y * (0.3549632885e3 + $y)))));
991	$fRet = $f1 / $f2 + 0.636619772 * ( self::BESSELJ($fNum, 1) * log($fNum) - 1 / $fNum);
992	} else {
993	$fRet = sqrt(0.636619772 / $fNum) * sin($fNum - 2.356194491);
994	}
995	return $fRet;
996	} // function _Bessely1()
997
998
999	/**
1000	* BESSELY
1001	*
1002	* Returns the Bessel function, which is also called the Weber function or the Neumann function.
1003	*
1004	* Excel Function:
1005	* BESSELY(x,ord)
1006	*
1007	* @access public
1008	* @category Engineering Functions
1009	* @param float $x The value at which to evaluate the function.
1010	* If x is nonnumeric, BESSELK returns the #VALUE! error value.
1011	* @param integer $ord The order of the Bessel function. If n is not an integer, it is truncated.
1012	* If $ord is nonnumeric, BESSELK returns the #VALUE! error value.
1013	* If $ord < 0, BESSELK returns the #NUM! error value.
1014	*
1015	* @return float
1016	*/
1017	public static function BESSELY($x, $ord) {
1018	$x = (is_null($x)) ? 0.0 : PHPExcel_Calculation_Functions::flattenSingleValue($x);
1019	$ord = (is_null($ord)) ? 0.0 : PHPExcel_Calculation_Functions::flattenSingleValue($ord);
1020
1021	if ((is_numeric($x)) && (is_numeric($ord))) {
1022	if (($ord < 0) \|\| ($x == 0.0)) {
1023	return PHPExcel_Calculation_Functions::NaN();
1024	}
1025
1026	switch(floor($ord)) {
1027	case 0 : return self::_Bessely0($x);
1028	break;
1029	case 1 : return self::_Bessely1($x);
1030	break;
1031	default: $fTox = 2 / $x;
1032	$fBym = self::_Bessely0($x);
1033	$fBy = self::_Bessely1($x);
1034	for ($n = 1; $n < $ord; ++$n) {
1035	$fByp = $n * $fTox * $fBy - $fBym;
1036	$fBym = $fBy;
1037	$fBy = $fByp;
1038	}
1039	}
1040	return (is_nan($fBy)) ? PHPExcel_Calculation_Functions::NaN() : $fBy;
1041	}
1042	return PHPExcel_Calculation_Functions::VALUE();
1043	} // function BESSELY()
1044
1045
1046	/**
1047	* BINTODEC
1048	*
1049	* Return a binary value as decimal.
1050	*
1051	* Excel Function:
1052	* BIN2DEC(x)
1053	*
1054	* @access public
1055	* @category Engineering Functions
1056	* @param string $x The binary number (as a string) that you want to convert. The number
1057	* cannot contain more than 10 characters (10 bits). The most significant
1058	* bit of number is the sign bit. The remaining 9 bits are magnitude bits.
1059	* Negative numbers are represented using two's-complement notation.
1060	* If number is not a valid binary number, or if number contains more than
1061	* 10 characters (10 bits), BIN2DEC returns the #NUM! error value.
1062	* @return string
1063	*/
1064	public static function BINTODEC($x) {
1065	$x = PHPExcel_Calculation_Functions::flattenSingleValue($x);
1066
1067	if (is_bool($x)) {
1068	if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE) {
1069	$x = (int) $x;
1070	} else {
1071	return PHPExcel_Calculation_Functions::VALUE();
1072	}
1073	}
1074	if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC) {
1075	$x = floor($x);
1076	}
1077	$x = (string) $x;
1078	if (strlen($x) > preg_match_all('/[01]/',$x,$out)) {
1079	return PHPExcel_Calculation_Functions::NaN();
1080	}
1081	if (strlen($x) > 10) {
1082	return PHPExcel_Calculation_Functions::NaN();
1083	} elseif (strlen($x) == 10) {
1084	// Two's Complement
1085	$x = substr($x,-9);
1086	return '-'.(512-bindec($x));
1087	}
1088	return bindec($x);
1089	} // function BINTODEC()
1090
1091
1092	/**
1093	* BINTOHEX
1094	*
1095	* Return a binary value as hex.
1096	*
1097	* Excel Function:
1098	* BIN2HEX(x[,places])
1099	*
1100	* @access public
1101	* @category Engineering Functions
1102	* @param string $x The binary number (as a string) that you want to convert. The number
1103	* cannot contain more than 10 characters (10 bits). The most significant
1104	* bit of number is the sign bit. The remaining 9 bits are magnitude bits.
1105	* Negative numbers are represented using two's-complement notation.
1106	* If number is not a valid binary number, or if number contains more than
1107	* 10 characters (10 bits), BIN2HEX returns the #NUM! error value.
1108	* @param integer $places The number of characters to use. If places is omitted, BIN2HEX uses the
1109	* minimum number of characters necessary. Places is useful for padding the
1110	* return value with leading 0s (zeros).
1111	* If places is not an integer, it is truncated.
1112	* If places is nonnumeric, BIN2HEX returns the #VALUE! error value.
1113	* If places is negative, BIN2HEX returns the #NUM! error value.
1114	* @return string
1115	*/
1116	public static function BINTOHEX($x, $places=NULL) {
1117	$x = PHPExcel_Calculation_Functions::flattenSingleValue($x);
1118	$places = PHPExcel_Calculation_Functions::flattenSingleValue($places);
1119
1120	if (is_bool($x)) {
1121	if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE) {
1122	$x = (int) $x;
1123	} else {
1124	return PHPExcel_Calculation_Functions::VALUE();
1125	}
1126	}
1127	if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC) {
1128	$x = floor($x);
1129	}
1130	$x = (string) $x;
1131	if (strlen($x) > preg_match_all('/[01]/',$x,$out)) {
1132	return PHPExcel_Calculation_Functions::NaN();
1133	}
1134	if (strlen($x) > 10) {
1135	return PHPExcel_Calculation_Functions::NaN();
1136	} elseif (strlen($x) == 10) {
1137	// Two's Complement
1138	return str_repeat('F',8).substr(strtoupper(dechex(bindec(substr($x,-9)))),-2);
1139	}
1140	$hexVal = (string) strtoupper(dechex(bindec($x)));
1141
1142	return self::_nbrConversionFormat($hexVal,$places);
1143	} // function BINTOHEX()
1144
1145
1146	/**
1147	* BINTOOCT
1148	*
1149	* Return a binary value as octal.
1150	*
1151	* Excel Function:
1152	* BIN2OCT(x[,places])
1153	*
1154	* @access public
1155	* @category Engineering Functions
1156	* @param string $x The binary number (as a string) that you want to convert. The number
1157	* cannot contain more than 10 characters (10 bits). The most significant
1158	* bit of number is the sign bit. The remaining 9 bits are magnitude bits.
1159	* Negative numbers are represented using two's-complement notation.
1160	* If number is not a valid binary number, or if number contains more than
1161	* 10 characters (10 bits), BIN2OCT returns the #NUM! error value.
1162	* @param integer $places The number of characters to use. If places is omitted, BIN2OCT uses the
1163	* minimum number of characters necessary. Places is useful for padding the
1164	* return value with leading 0s (zeros).
1165	* If places is not an integer, it is truncated.
1166	* If places is nonnumeric, BIN2OCT returns the #VALUE! error value.
1167	* If places is negative, BIN2OCT returns the #NUM! error value.
1168	* @return string
1169	*/
1170	public static function BINTOOCT($x, $places=NULL) {
1171	$x = PHPExcel_Calculation_Functions::flattenSingleValue($x);
1172	$places = PHPExcel_Calculation_Functions::flattenSingleValue($places);
1173
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	if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC) {
1182	$x = floor($x);
1183	}
1184	$x = (string) $x;
1185	if (strlen($x) > preg_match_all('/[01]/',$x,$out)) {
1186	return PHPExcel_Calculation_Functions::NaN();
1187	}
1188	if (strlen($x) > 10) {
1189	return PHPExcel_Calculation_Functions::NaN();
1190	} elseif (strlen($x) == 10) {
1191	// Two's Complement
1192	return str_repeat('7',7).substr(strtoupper(decoct(bindec(substr($x,-9)))),-3);
1193	}
1194	$octVal = (string) decoct(bindec($x));
1195
1196	return self::_nbrConversionFormat($octVal,$places);
1197	} // function BINTOOCT()
1198
1199
1200	/**
1201	* DECTOBIN
1202	*
1203	* Return a decimal value as binary.
1204	*
1205	* Excel Function:
1206	* DEC2BIN(x[,places])
1207	*
1208	* @access public
1209	* @category Engineering Functions
1210	* @param string $x The decimal integer you want to convert. If number is negative,
1211	* valid place values are ignored and DEC2BIN returns a 10-character
1212	* (10-bit) binary number in which the most significant bit is the sign
1213	* bit. The remaining 9 bits are magnitude bits. Negative numbers are
1214	* represented using two's-complement notation.
1215	* If number < -512 or if number > 511, DEC2BIN returns the #NUM! error
1216	* value.
1217	* If number is nonnumeric, DEC2BIN returns the #VALUE! error value.
1218	* If DEC2BIN requires more than places characters, it returns the #NUM!
1219	* error value.
1220	* @param integer $places The number of characters to use. If places is omitted, DEC2BIN uses
1221	* the minimum number of characters necessary. Places is useful for
1222	* padding the return value with leading 0s (zeros).
1223	* If places is not an integer, it is truncated.
1224	* If places is nonnumeric, DEC2BIN returns the #VALUE! error value.
1225	* If places is zero or negative, DEC2BIN returns the #NUM! error value.
1226	* @return string
1227	*/
1228	public static function DECTOBIN($x, $places=NULL) {
1229	$x = PHPExcel_Calculation_Functions::flattenSingleValue($x);
1230	$places = PHPExcel_Calculation_Functions::flattenSingleValue($places);
1231
1232	if (is_bool($x)) {
1233	if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE) {
1234	$x = (int) $x;
1235	} else {
1236	return PHPExcel_Calculation_Functions::VALUE();
1237	}
1238	}
1239	$x = (string) $x;
1240	if (strlen($x) > preg_match_all('/[-0123456789.]/',$x,$out)) {
1241	return PHPExcel_Calculation_Functions::VALUE();
1242	}
1243	$x = (string) floor($x);
1244	$r = decbin($x);
1245	if (strlen($r) == 32) {
1246	// Two's Complement
1247	$r = substr($r,-10);
1248	} elseif (strlen($r) > 11) {
1249	return PHPExcel_Calculation_Functions::NaN();
1250	}
1251
1252	return self::_nbrConversionFormat($r,$places);
1253	} // function DECTOBIN()
1254
1255
1256	/**
1257	* DECTOHEX
1258	*
1259	* Return a decimal value as hex.
1260	*
1261	* Excel Function:
1262	* DEC2HEX(x[,places])
1263	*
1264	* @access public
1265	* @category Engineering Functions
1266	* @param string $x The decimal integer you want to convert. If number is negative,
1267	* places is ignored and DEC2HEX returns a 10-character (40-bit)
1268	* hexadecimal number in which the most significant bit is the sign
1269	* bit. The remaining 39 bits are magnitude bits. Negative numbers
1270	* are represented using two's-complement notation.
1271	* If number < -549,755,813,888 or if number > 549,755,813,887,
1272	* DEC2HEX returns the #NUM! error value.
1273	* If number is nonnumeric, DEC2HEX returns the #VALUE! error value.
1274	* If DEC2HEX requires more than places characters, it returns the
1275	* #NUM! error value.
1276	* @param integer $places The number of characters to use. If places is omitted, DEC2HEX uses
1277	* the minimum number of characters necessary. Places is useful for
1278	* padding the return value with leading 0s (zeros).
1279	* If places is not an integer, it is truncated.
1280	* If places is nonnumeric, DEC2HEX returns the #VALUE! error value.
1281	* If places is zero or negative, DEC2HEX returns the #NUM! error value.
1282	* @return string
1283	*/
1284	public static function DECTOHEX($x, $places=null) {
1285	$x = PHPExcel_Calculation_Functions::flattenSingleValue($x);
1286	$places = PHPExcel_Calculation_Functions::flattenSingleValue($places);
1287
1288	if (is_bool($x)) {
1289	if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE) {
1290	$x = (int) $x;
1291	} else {
1292	return PHPExcel_Calculation_Functions::VALUE();
1293	}
1294	}
1295	$x = (string) $x;
1296	if (strlen($x) > preg_match_all('/[-0123456789.]/',$x,$out)) {
1297	return PHPExcel_Calculation_Functions::VALUE();
1298	}
1299	$x = (string) floor($x);
1300	$r = strtoupper(dechex($x));
1301	if (strlen($r) == 8) {
1302	// Two's Complement
1303	$r = 'FF'.$r;
1304	}
1305
1306	return self::_nbrConversionFormat($r,$places);
1307	} // function DECTOHEX()
1308
1309
1310	/**
1311	* DECTOOCT
1312	*
1313	* Return an decimal value as octal.
1314	*
1315	* Excel Function:
1316	* DEC2OCT(x[,places])
1317	*
1318	* @access public
1319	* @category Engineering Functions
1320	* @param string $x The decimal integer you want to convert. If number is negative,
1321	* places is ignored and DEC2OCT returns a 10-character (30-bit)
1322	* octal number in which the most significant bit is the sign bit.
1323	* The remaining 29 bits are magnitude bits. Negative numbers are
1324	* represented using two's-complement notation.
1325	* If number < -536,870,912 or if number > 536,870,911, DEC2OCT
1326	* returns the #NUM! error value.
1327	* If number is nonnumeric, DEC2OCT returns the #VALUE! error value.
1328	* If DEC2OCT requires more than places characters, it returns the
1329	* #NUM! error value.
1330	* @param integer $places The number of characters to use. If places is omitted, DEC2OCT uses
1331	* the minimum number of characters necessary. Places is useful for
1332	* padding the return value with leading 0s (zeros).
1333	* If places is not an integer, it is truncated.
1334	* If places is nonnumeric, DEC2OCT returns the #VALUE! error value.
1335	* If places is zero or negative, DEC2OCT returns the #NUM! error value.
1336	* @return string
1337	*/
1338	public static function DECTOOCT($x, $places=null) {
1339	$x = PHPExcel_Calculation_Functions::flattenSingleValue($x);
1340	$places = PHPExcel_Calculation_Functions::flattenSingleValue($places);
1341
1342	if (is_bool($x)) {
1343	if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE) {
1344	$x = (int) $x;
1345	} else {
1346	return PHPExcel_Calculation_Functions::VALUE();
1347	}
1348	}
1349	$x = (string) $x;
1350	if (strlen($x) > preg_match_all('/[-0123456789.]/',$x,$out)) {
1351	return PHPExcel_Calculation_Functions::VALUE();
1352	}
1353	$x = (string) floor($x);
1354	$r = decoct($x);
1355	if (strlen($r) == 11) {
1356	// Two's Complement
1357	$r = substr($r,-10);
1358	}
1359
1360	return self::_nbrConversionFormat($r,$places);
1361	} // function DECTOOCT()
1362
1363
1364	/**
1365	* HEXTOBIN
1366	*
1367	* Return a hex value as binary.
1368	*
1369	* Excel Function:
1370	* HEX2BIN(x[,places])
1371	*
1372	* @access public
1373	* @category Engineering Functions
1374	* @param string $x the hexadecimal number you want to convert. Number cannot
1375	* contain more than 10 characters. The most significant bit of
1376	* number is the sign bit (40th bit from the right). The remaining
1377	* 9 bits are magnitude bits. Negative numbers are represented
1378	* using two's-complement notation.
1379	* If number is negative, HEX2BIN ignores places and returns a
1380	* 10-character binary number.
1381	* If number is negative, it cannot be less than FFFFFFFE00, and
1382	* if number is positive, it cannot be greater than 1FF.
1383	* If number is not a valid hexadecimal number, HEX2BIN returns
1384	* the #NUM! error value.
1385	* If HEX2BIN requires more than places characters, it returns
1386	* the #NUM! error value.
1387	* @param integer $places The number of characters to use. If places is omitted,
1388	* HEX2BIN uses the minimum number of characters necessary. Places
1389	* is useful for padding the return value with leading 0s (zeros).
1390	* If places is not an integer, it is truncated.
1391	* If places is nonnumeric, HEX2BIN returns the #VALUE! error value.
1392	* If places is negative, HEX2BIN returns the #NUM! error value.
1393	* @return string
1394	*/
1395	public static function HEXTOBIN($x, $places=null) {
1396	$x = PHPExcel_Calculation_Functions::flattenSingleValue($x);
1397	$places = PHPExcel_Calculation_Functions::flattenSingleValue($places);
1398
1399	if (is_bool($x)) {
1400	return PHPExcel_Calculation_Functions::VALUE();
1401	}
1402	$x = (string) $x;
1403	if (strlen($x) > preg_match_all('/[0123456789ABCDEF]/',strtoupper($x),$out)) {
1404	return PHPExcel_Calculation_Functions::NaN();
1405	}
1406	$binVal = decbin(hexdec($x));
1407
1408	return substr(self::_nbrConversionFormat($binVal,$places),-10);
1409	} // function HEXTOBIN()
1410
1411
1412	/**
1413	* HEXTODEC
1414	*
1415	* Return a hex value as decimal.
1416	*
1417	* Excel Function:
1418	* HEX2DEC(x)
1419	*
1420	* @access public
1421	* @category Engineering Functions
1422	* @param string $x The hexadecimal number you want to convert. This number cannot
1423	* contain more than 10 characters (40 bits). The most significant
1424	* bit of number is the sign bit. The remaining 39 bits are magnitude
1425	* bits. Negative numbers are represented using two's-complement
1426	* notation.
1427	* If number is not a valid hexadecimal number, HEX2DEC returns the
1428	* #NUM! error value.
1429	* @return string
1430	*/
1431	public static function HEXTODEC($x) {
1432	$x = PHPExcel_Calculation_Functions::flattenSingleValue($x);
1433
1434	if (is_bool($x)) {
1435	return PHPExcel_Calculation_Functions::VALUE();
1436	}
1437	$x = (string) $x;
1438	if (strlen($x) > preg_match_all('/[0123456789ABCDEF]/',strtoupper($x),$out)) {
1439	return PHPExcel_Calculation_Functions::NaN();
1440	}
1441	return hexdec($x);
1442	} // function HEXTODEC()
1443
1444
1445	/**
1446	* HEXTOOCT
1447	*
1448	* Return a hex value as octal.
1449	*
1450	* Excel Function:
1451	* HEX2OCT(x[,places])
1452	*
1453	* @access public
1454	* @category Engineering Functions
1455	* @param string $x The hexadecimal number you want to convert. Number cannot
1456	* contain more than 10 characters. The most significant bit of
1457	* number is the sign bit. The remaining 39 bits are magnitude
1458	* bits. Negative numbers are represented using two's-complement
1459	* notation.
1460	* If number is negative, HEX2OCT ignores places and returns a
1461	* 10-character octal number.
1462	* If number is negative, it cannot be less than FFE0000000, and
1463	* if number is positive, it cannot be greater than 1FFFFFFF.
1464	* If number is not a valid hexadecimal number, HEX2OCT returns
1465	* the #NUM! error value.
1466	* If HEX2OCT requires more than places characters, it returns
1467	* the #NUM! error value.
1468	* @param integer $places The number of characters to use. If places is omitted, HEX2OCT
1469	* uses the minimum number of characters necessary. Places is
1470	* useful for padding the return value with leading 0s (zeros).
1471	* If places is not an integer, it is truncated.
1472	* If places is nonnumeric, HEX2OCT returns the #VALUE! error
1473	* value.
1474	* If places is negative, HEX2OCT returns the #NUM! error value.
1475	* @return string
1476	*/
1477	public static function HEXTOOCT($x, $places=null) {
1478	$x = PHPExcel_Calculation_Functions::flattenSingleValue($x);
1479	$places = PHPExcel_Calculation_Functions::flattenSingleValue($places);
1480
1481	if (is_bool($x)) {
1482	return PHPExcel_Calculation_Functions::VALUE();
1483	}
1484	$x = (string) $x;
1485	if (strlen($x) > preg_match_all('/[0123456789ABCDEF]/',strtoupper($x),$out)) {
1486	return PHPExcel_Calculation_Functions::NaN();
1487	}
1488	$octVal = decoct(hexdec($x));
1489
1490	return self::_nbrConversionFormat($octVal,$places);
1491	} // function HEXTOOCT()
1492
1493
1494	/**
1495	* OCTTOBIN
1496	*
1497	* Return an octal value as binary.
1498	*
1499	* Excel Function:
1500	* OCT2BIN(x[,places])
1501	*
1502	* @access public
1503	* @category Engineering Functions
1504	* @param string $x The octal number you want to convert. Number may not
1505	* contain more than 10 characters. The most significant
1506	* bit of number is the sign bit. The remaining 29 bits
1507	* are magnitude bits. Negative numbers are represented
1508	* using two's-complement notation.
1509	* If number is negative, OCT2BIN ignores places and returns
1510	* a 10-character binary number.
1511	* If number is negative, it cannot be less than 7777777000,
1512	* and if number is positive, it cannot be greater than 777.
1513	* If number is not a valid octal number, OCT2BIN returns
1514	* the #NUM! error value.
1515	* If OCT2BIN requires more than places characters, it
1516	* returns the #NUM! error value.
1517	* @param integer $places The number of characters to use. If places is omitted,
1518	* OCT2BIN uses the minimum number of characters necessary.
1519	* Places is useful for padding the return value with
1520	* leading 0s (zeros).
1521	* If places is not an integer, it is truncated.
1522	* If places is nonnumeric, OCT2BIN returns the #VALUE!
1523	* error value.
1524	* If places is negative, OCT2BIN returns the #NUM! error
1525	* value.
1526	* @return string
1527	*/
1528	public static function OCTTOBIN($x, $places=null) {
1529	$x = PHPExcel_Calculation_Functions::flattenSingleValue($x);
1530	$places = PHPExcel_Calculation_Functions::flattenSingleValue($places);
1531
1532	if (is_bool($x)) {
1533	return PHPExcel_Calculation_Functions::VALUE();
1534	}
1535	$x = (string) $x;
1536	if (preg_match_all('/[01234567]/',$x,$out) != strlen($x)) {
1537	return PHPExcel_Calculation_Functions::NaN();
1538	}
1539	$r = decbin(octdec($x));
1540
1541	return self::_nbrConversionFormat($r,$places);
1542	} // function OCTTOBIN()
1543
1544
1545	/**
1546	* OCTTODEC
1547	*
1548	* Return an octal value as decimal.
1549	*
1550	* Excel Function:
1551	* OCT2DEC(x)
1552	*
1553	* @access public
1554	* @category Engineering Functions
1555	* @param string $x The octal number you want to convert. Number may not contain
1556	* more than 10 octal characters (30 bits). The most significant
1557	* bit of number is the sign bit. The remaining 29 bits are
1558	* magnitude bits. Negative numbers are represented using
1559	* two's-complement notation.
1560	* If number is not a valid octal number, OCT2DEC returns the
1561	* #NUM! error value.
1562	* @return string
1563	*/
1564	public static function OCTTODEC($x) {
1565	$x = PHPExcel_Calculation_Functions::flattenSingleValue($x);
1566
1567	if (is_bool($x)) {
1568	return PHPExcel_Calculation_Functions::VALUE();
1569	}
1570	$x = (string) $x;
1571	if (preg_match_all('/[01234567]/',$x,$out) != strlen($x)) {
1572	return PHPExcel_Calculation_Functions::NaN();
1573	}
1574	return octdec($x);
1575	} // function OCTTODEC()
1576
1577
1578	/**
1579	* OCTTOHEX
1580	*
1581	* Return an octal value as hex.
1582	*
1583	* Excel Function:
1584	* OCT2HEX(x[,places])
1585	*
1586	* @access public
1587	* @category Engineering Functions
1588	* @param string $x The octal number you want to convert. Number may not contain
1589	* more than 10 octal characters (30 bits). The most significant
1590	* bit of number is the sign bit. The remaining 29 bits are
1591	* magnitude bits. Negative numbers are represented using
1592	* two's-complement notation.
1593	* If number is negative, OCT2HEX ignores places and returns a
1594	* 10-character hexadecimal number.
1595	* If number is not a valid octal number, OCT2HEX returns the
1596	* #NUM! error value.
1597	* If OCT2HEX requires more than places characters, it returns
1598	* the #NUM! error value.
1599	* @param integer $places The number of characters to use. If places is omitted, OCT2HEX
1600	* uses the minimum number of characters necessary. Places is useful
1601	* for padding the return value with leading 0s (zeros).
1602	* If places is not an integer, it is truncated.
1603	* If places is nonnumeric, OCT2HEX returns the #VALUE! error value.
1604	* If places is negative, OCT2HEX returns the #NUM! error value.
1605	* @return string
1606	*/
1607	public static function OCTTOHEX($x, $places=null) {
1608	$x = PHPExcel_Calculation_Functions::flattenSingleValue($x);
1609	$places = PHPExcel_Calculation_Functions::flattenSingleValue($places);
1610
1611	if (is_bool($x)) {
1612	return PHPExcel_Calculation_Functions::VALUE();
1613	}
1614	$x = (string) $x;
1615	if (preg_match_all('/[01234567]/',$x,$out) != strlen($x)) {
1616	return PHPExcel_Calculation_Functions::NaN();
1617	}
1618	$hexVal = strtoupper(dechex(octdec($x)));
1619
1620	return self::_nbrConversionFormat($hexVal,$places);
1621	} // function OCTTOHEX()
1622
1623
1624	/**
1625	* COMPLEX
1626	*
1627	* Converts real and imaginary coefficients into a complex number of the form x + yi or x + yj.
1628	*
1629	* Excel Function:
1630	* COMPLEX(realNumber,imaginary[,places])
1631	*
1632	* @access public
1633	* @category Engineering Functions
1634	* @param float $realNumber The real coefficient of the complex number.
1635	* @param float $imaginary The imaginary coefficient of the complex number.
1636	* @param string $suffix The suffix for the imaginary component of the complex number.
1637	* If omitted, the suffix is assumed to be "i".
1638	* @return string
1639	*/
1640	public static function COMPLEX($realNumber=0.0, $imaginary=0.0, $suffix='i') {
1641	$realNumber = (is_null($realNumber)) ? 0.0 : PHPExcel_Calculation_Functions::flattenSingleValue($realNumber);
1642	$imaginary = (is_null($imaginary)) ? 0.0 : PHPExcel_Calculation_Functions::flattenSingleValue($imaginary);
1643	$suffix = (is_null($suffix)) ? 'i' : PHPExcel_Calculation_Functions::flattenSingleValue($suffix);
1644
1645	if (((is_numeric($realNumber)) && (is_numeric($imaginary))) &&
1646	(($suffix == 'i') \|\| ($suffix == 'j') \|\| ($suffix == ''))) {
1647	$realNumber = (float) $realNumber;
1648	$imaginary = (float) $imaginary;
1649
1650	if ($suffix == '') $suffix = 'i';
1651	if ($realNumber == 0.0) {
1652	if ($imaginary == 0.0) {
1653	return (string) '0';
1654	} elseif ($imaginary == 1.0) {
1655	return (string) $suffix;
1656	} elseif ($imaginary == -1.0) {
1657	return (string) '-'.$suffix;
1658	}
1659	return (string) $imaginary.$suffix;
1660	} elseif ($imaginary == 0.0) {
1661	return (string) $realNumber;
1662	} elseif ($imaginary == 1.0) {
1663	return (string) $realNumber.'+'.$suffix;
1664	} elseif ($imaginary == -1.0) {
1665	return (string) $realNumber.'-'.$suffix;
1666	}
1667	if ($imaginary > 0) { $imaginary = (string) '+'.$imaginary; }
1668	return (string) $realNumber.$imaginary.$suffix;
1669	}
1670
1671	return PHPExcel_Calculation_Functions::VALUE();
1672	} // function COMPLEX()
1673
1674
1675	/**
1676	* IMAGINARY
1677	*
1678	* Returns the imaginary coefficient of a complex number in x + yi or x + yj text format.
1679	*
1680	* Excel Function:
1681	* IMAGINARY(complexNumber)
1682	*
1683	* @access public
1684	* @category Engineering Functions
1685	* @param string $complexNumber The complex number for which you want the imaginary
1686	* coefficient.
1687	* @return float
1688	*/
1689	public static function IMAGINARY($complexNumber) {
1690	$complexNumber = PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
1691
1692	$parsedComplex = self::_parseComplex($complexNumber);
1693	return $parsedComplex['imaginary'];
1694	} // function IMAGINARY()
1695
1696
1697	/**
1698	* IMREAL
1699	*
1700	* Returns the real coefficient of a complex number in x + yi or x + yj text format.
1701	*
1702	* Excel Function:
1703	* IMREAL(complexNumber)
1704	*
1705	* @access public
1706	* @category Engineering Functions
1707	* @param string $complexNumber The complex number for which you want the real coefficient.
1708	* @return float
1709	*/
1710	public static function IMREAL($complexNumber) {
1711	$complexNumber = PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
1712
1713	$parsedComplex = self::_parseComplex($complexNumber);
1714	return $parsedComplex['real'];
1715	} // function IMREAL()
1716
1717
1718	/**
1719	* IMABS
1720	*
1721	* Returns the absolute value (modulus) of a complex number in x + yi or x + yj text format.
1722	*
1723	* Excel Function:
1724	* IMABS(complexNumber)
1725	*
1726	* @param string $complexNumber The complex number for which you want the absolute value.
1727	* @return float
1728	*/
1729	public static function IMABS($complexNumber) {
1730	$complexNumber = PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
1731
1732	$parsedComplex = self::_parseComplex($complexNumber);
1733
1734	return sqrt(($parsedComplex['real'] * $parsedComplex['real']) + ($parsedComplex['imaginary'] * $parsedComplex['imaginary']));
1735	} // function IMABS()
1736
1737
1738	/**
1739	* IMARGUMENT
1740	*
1741	* Returns the argument theta of a complex number, i.e. the angle in radians from the real
1742	* axis to the representation of the number in polar coordinates.
1743	*
1744	* Excel Function:
1745	* IMARGUMENT(complexNumber)
1746	*
1747	* @param string $complexNumber The complex number for which you want the argument theta.
1748	* @return float
1749	*/
1750	public static function IMARGUMENT($complexNumber) {
1751	$complexNumber = PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
1752
1753	$parsedComplex = self::_parseComplex($complexNumber);
1754
1755	if ($parsedComplex['real'] == 0.0) {
1756	if ($parsedComplex['imaginary'] == 0.0) {
1757	return 0.0;
1758	} elseif($parsedComplex['imaginary'] < 0.0) {
1759	return M_PI / -2;
1760	} else {
1761	return M_PI / 2;
1762	}
1763	} elseif ($parsedComplex['real'] > 0.0) {
1764	return atan($parsedComplex['imaginary'] / $parsedComplex['real']);
1765	} elseif ($parsedComplex['imaginary'] < 0.0) {
1766	return 0 - (M_PI - atan(abs($parsedComplex['imaginary']) / abs($parsedComplex['real'])));
1767	} else {
1768	return M_PI - atan($parsedComplex['imaginary'] / abs($parsedComplex['real']));
1769	}
1770	} // function IMARGUMENT()
1771
1772
1773	/**
1774	* IMCONJUGATE
1775	*
1776	* Returns the complex conjugate of a complex number in x + yi or x + yj text format.
1777	*
1778	* Excel Function:
1779	* IMCONJUGATE(complexNumber)
1780	*
1781	* @param string $complexNumber The complex number for which you want the conjugate.
1782	* @return string
1783	*/
1784	public static function IMCONJUGATE($complexNumber) {
1785	$complexNumber = PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
1786
1787	$parsedComplex = self::_parseComplex($complexNumber);
1788
1789	if ($parsedComplex['imaginary'] == 0.0) {
1790	return $parsedComplex['real'];
1791	} else {
1792	return self::_cleanComplex( self::COMPLEX( $parsedComplex['real'],
1793	0 - $parsedComplex['imaginary'],
1794	$parsedComplex['suffix']
1795	)
1796	);
1797	}
1798	} // function IMCONJUGATE()
1799
1800
1801	/**
1802	* IMCOS
1803	*
1804	* Returns the cosine of a complex number in x + yi or x + yj text format.
1805	*
1806	* Excel Function:
1807	* IMCOS(complexNumber)
1808	*
1809	* @param string $complexNumber The complex number for which you want the cosine.
1810	* @return string\|float
1811	*/
1812	public static function IMCOS($complexNumber) {
1813	$complexNumber = PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
1814
1815	$parsedComplex = self::_parseComplex($complexNumber);
1816
1817	if ($parsedComplex['imaginary'] == 0.0) {
1818	return cos($parsedComplex['real']);
1819	} else {
1820	return self::IMCONJUGATE(self::COMPLEX(cos($parsedComplex['real']) * cosh($parsedComplex['imaginary']),sin($parsedComplex['real']) * sinh($parsedComplex['imaginary']),$parsedComplex['suffix']));
1821	}
1822	} // function IMCOS()
1823
1824
1825	/**
1826	* IMSIN
1827	*
1828	* Returns the sine of a complex number in x + yi or x + yj text format.
1829	*
1830	* Excel Function:
1831	* IMSIN(complexNumber)
1832	*
1833	* @param string $complexNumber The complex number for which you want the sine.
1834	* @return string\|float
1835	*/
1836	public static function IMSIN($complexNumber) {
1837	$complexNumber = PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
1838
1839	$parsedComplex = self::_parseComplex($complexNumber);
1840
1841	if ($parsedComplex['imaginary'] == 0.0) {
1842	return sin($parsedComplex['real']);
1843	} else {
1844	return self::COMPLEX(sin($parsedComplex['real']) * cosh($parsedComplex['imaginary']),cos($parsedComplex['real']) * sinh($parsedComplex['imaginary']),$parsedComplex['suffix']);
1845	}
1846	} // function IMSIN()
1847
1848
1849	/**
1850	* IMSQRT
1851	*
1852	* Returns the square root of a complex number in x + yi or x + yj text format.
1853	*
1854	* Excel Function:
1855	* IMSQRT(complexNumber)
1856	*
1857	* @param string $complexNumber The complex number for which you want the square root.
1858	* @return string
1859	*/
1860	public static function IMSQRT($complexNumber) {
1861	$complexNumber = PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
1862
1863	$parsedComplex = self::_parseComplex($complexNumber);
1864
1865	$theta = self::IMARGUMENT($complexNumber);
1866	$d1 = cos($theta / 2);
1867	$d2 = sin($theta / 2);
1868	$r = sqrt(sqrt(($parsedComplex['real'] * $parsedComplex['real']) + ($parsedComplex['imaginary'] * $parsedComplex['imaginary'])));
1869
1870	if ($parsedComplex['suffix'] == '') {
1871	return self::COMPLEX($d1 * $r,$d2 * $r);
1872	} else {
1873	return self::COMPLEX($d1 * $r,$d2 * $r,$parsedComplex['suffix']);
1874	}
1875	} // function IMSQRT()
1876
1877
1878	/**
1879	* IMLN
1880	*
1881	* Returns the natural logarithm of a complex number in x + yi or x + yj text format.
1882	*
1883	* Excel Function:
1884	* IMLN(complexNumber)
1885	*
1886	* @param string $complexNumber The complex number for which you want the natural logarithm.
1887	* @return string
1888	*/
1889	public static function IMLN($complexNumber) {
1890	$complexNumber = PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
1891
1892	$parsedComplex = self::_parseComplex($complexNumber);
1893
1894	if (($parsedComplex['real'] == 0.0) && ($parsedComplex['imaginary'] == 0.0)) {
1895	return PHPExcel_Calculation_Functions::NaN();
1896	}
1897
1898	$logR = log(sqrt(($parsedComplex['real'] * $parsedComplex['real']) + ($parsedComplex['imaginary'] * $parsedComplex['imaginary'])));
1899	$t = self::IMARGUMENT($complexNumber);
1900
1901	if ($parsedComplex['suffix'] == '') {
1902	return self::COMPLEX($logR,$t);
1903	} else {
1904	return self::COMPLEX($logR,$t,$parsedComplex['suffix']);
1905	}
1906	} // function IMLN()
1907
1908
1909	/**
1910	* IMLOG10
1911	*
1912	* Returns the common logarithm (base 10) of a complex number in x + yi or x + yj text format.
1913	*
1914	* Excel Function:
1915	* IMLOG10(complexNumber)
1916	*
1917	* @param string $complexNumber The complex number for which you want the common logarithm.
1918	* @return string
1919	*/
1920	public static function IMLOG10($complexNumber) {
1921	$complexNumber = PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
1922
1923	$parsedComplex = self::_parseComplex($complexNumber);
1924
1925	if (($parsedComplex['real'] == 0.0) && ($parsedComplex['imaginary'] == 0.0)) {
1926	return PHPExcel_Calculation_Functions::NaN();
1927	} elseif (($parsedComplex['real'] > 0.0) && ($parsedComplex['imaginary'] == 0.0)) {
1928	return log10($parsedComplex['real']);
1929	}
1930
1931	return self::IMPRODUCT(log10(EULER),self::IMLN($complexNumber));
1932	} // function IMLOG10()
1933
1934
1935	/**
1936	* IMLOG2
1937	*
1938	* Returns the base-2 logarithm of a complex number in x + yi or x + yj text format.
1939	*
1940	* Excel Function:
1941	* IMLOG2(complexNumber)
1942	*
1943	* @param string $complexNumber The complex number for which you want the base-2 logarithm.
1944	* @return string
1945	*/
1946	public static function IMLOG2($complexNumber) {
1947	$complexNumber = PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
1948
1949	$parsedComplex = self::_parseComplex($complexNumber);
1950
1951	if (($parsedComplex['real'] == 0.0) && ($parsedComplex['imaginary'] == 0.0)) {
1952	return PHPExcel_Calculation_Functions::NaN();
1953	} elseif (($parsedComplex['real'] > 0.0) && ($parsedComplex['imaginary'] == 0.0)) {
1954	return log($parsedComplex['real'],2);
1955	}
1956
1957	return self::IMPRODUCT(log(EULER,2),self::IMLN($complexNumber));
1958	} // function IMLOG2()
1959
1960
1961	/**
1962	* IMEXP
1963	*
1964	* Returns the exponential of a complex number in x + yi or x + yj text format.
1965	*
1966	* Excel Function:
1967	* IMEXP(complexNumber)
1968	*
1969	* @param string $complexNumber The complex number for which you want the exponential.
1970	* @return string
1971	*/
1972	public static function IMEXP($complexNumber) {
1973	$complexNumber = PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
1974
1975	$parsedComplex = self::_parseComplex($complexNumber);
1976
1977	if (($parsedComplex['real'] == 0.0) && ($parsedComplex['imaginary'] == 0.0)) {
1978	return '1';
1979	}
1980
1981	$e = exp($parsedComplex['real']);
1982	$eX = $e * cos($parsedComplex['imaginary']);
1983	$eY = $e * sin($parsedComplex['imaginary']);
1984
1985	if ($parsedComplex['suffix'] == '') {
1986	return self::COMPLEX($eX,$eY);
1987	} else {
1988	return self::COMPLEX($eX,$eY,$parsedComplex['suffix']);
1989	}
1990	} // function IMEXP()
1991
1992
1993	/**
1994	* IMPOWER
1995	*
1996	* Returns a complex number in x + yi or x + yj text format raised to a power.
1997	*
1998	* Excel Function:
1999	* IMPOWER(complexNumber,realNumber)
2000	*
2001	* @param string $complexNumber The complex number you want to raise to a power.
2002	* @param float $realNumber The power to which you want to raise the complex number.
2003	* @return string
2004	*/
2005	public static function IMPOWER($complexNumber,$realNumber) {
2006	$complexNumber = PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
2007	$realNumber = PHPExcel_Calculation_Functions::flattenSingleValue($realNumber);
2008
2009	if (!is_numeric($realNumber)) {
2010	return PHPExcel_Calculation_Functions::VALUE();
2011	}
2012
2013	$parsedComplex = self::_parseComplex($complexNumber);
2014
2015	$r = sqrt(($parsedComplex['real'] * $parsedComplex['real']) + ($parsedComplex['imaginary'] * $parsedComplex['imaginary']));
2016	$rPower = pow($r,$realNumber);
2017	$theta = self::IMARGUMENT($complexNumber) * $realNumber;
2018	if ($theta == 0) {
2019	return 1;
2020	} elseif ($parsedComplex['imaginary'] == 0.0) {
2021	return self::COMPLEX($rPower * cos($theta),$rPower * sin($theta),$parsedComplex['suffix']);
2022	} else {
2023	return self::COMPLEX($rPower * cos($theta),$rPower * sin($theta),$parsedComplex['suffix']);
2024	}
2025	} // function IMPOWER()
2026
2027
2028	/**
2029	* IMDIV
2030	*
2031	* Returns the quotient of two complex numbers in x + yi or x + yj text format.
2032	*
2033	* Excel Function:
2034	* IMDIV(complexDividend,complexDivisor)
2035	*
2036	* @param string $complexDividend The complex numerator or dividend.
2037	* @param string $complexDivisor The complex denominator or divisor.
2038	* @return string
2039	*/
2040	public static function IMDIV($complexDividend,$complexDivisor) {
2041	$complexDividend = PHPExcel_Calculation_Functions::flattenSingleValue($complexDividend);
2042	$complexDivisor = PHPExcel_Calculation_Functions::flattenSingleValue($complexDivisor);
2043
2044	$parsedComplexDividend = self::_parseComplex($complexDividend);
2045	$parsedComplexDivisor = self::_parseComplex($complexDivisor);
2046
2047	if (($parsedComplexDividend['suffix'] != '') && ($parsedComplexDivisor['suffix'] != '') &&
2048	($parsedComplexDividend['suffix'] != $parsedComplexDivisor['suffix'])) {
2049	return PHPExcel_Calculation_Functions::NaN();
2050	}
2051	if (($parsedComplexDividend['suffix'] != '') && ($parsedComplexDivisor['suffix'] == '')) {
2052	$parsedComplexDivisor['suffix'] = $parsedComplexDividend['suffix'];
2053	}
2054
2055	$d1 = ($parsedComplexDividend['real'] * $parsedComplexDivisor['real']) + ($parsedComplexDividend['imaginary'] * $parsedComplexDivisor['imaginary']);
2056	$d2 = ($parsedComplexDividend['imaginary'] * $parsedComplexDivisor['real']) - ($parsedComplexDividend['real'] * $parsedComplexDivisor['imaginary']);
2057	$d3 = ($parsedComplexDivisor['real'] * $parsedComplexDivisor['real']) + ($parsedComplexDivisor['imaginary'] * $parsedComplexDivisor['imaginary']);
2058
2059	$r = $d1/$d3;
2060	$i = $d2/$d3;
2061
2062	if ($i > 0.0) {
2063	return self::_cleanComplex($r.'+'.$i.$parsedComplexDivisor['suffix']);
2064	} elseif ($i < 0.0) {
2065	return self::_cleanComplex($r.$i.$parsedComplexDivisor['suffix']);
2066	} else {
2067	return $r;
2068	}
2069	} // function IMDIV()
2070
2071
2072	/**
2073	* IMSUB
2074	*
2075	* Returns the difference of two complex numbers in x + yi or x + yj text format.
2076	*
2077	* Excel Function:
2078	* IMSUB(complexNumber1,complexNumber2)
2079	*
2080	* @param string $complexNumber1 The complex number from which to subtract complexNumber2.
2081	* @param string $complexNumber2 The complex number to subtract from complexNumber1.
2082	* @return string
2083	*/
2084	public static function IMSUB($complexNumber1,$complexNumber2) {
2085	$complexNumber1 = PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber1);
2086	$complexNumber2 = PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber2);
2087
2088	$parsedComplex1 = self::_parseComplex($complexNumber1);
2089	$parsedComplex2 = self::_parseComplex($complexNumber2);
2090
2091	if ((($parsedComplex1['suffix'] != '') && ($parsedComplex2['suffix'] != '')) &&
2092	($parsedComplex1['suffix'] != $parsedComplex2['suffix'])) {
2093	return PHPExcel_Calculation_Functions::NaN();
2094	} elseif (($parsedComplex1['suffix'] == '') && ($parsedComplex2['suffix'] != '')) {
2095	$parsedComplex1['suffix'] = $parsedComplex2['suffix'];
2096	}
2097
2098	$d1 = $parsedComplex1['real'] - $parsedComplex2['real'];
2099	$d2 = $parsedComplex1['imaginary'] - $parsedComplex2['imaginary'];
2100
2101	return self::COMPLEX($d1,$d2,$parsedComplex1['suffix']);
2102	} // function IMSUB()
2103
2104
2105	/**
2106	* IMSUM
2107	*
2108	* Returns the sum of two or more complex numbers in x + yi or x + yj text format.
2109	*
2110	* Excel Function:
2111	* IMSUM(complexNumber[,complexNumber[,...]])
2112	*
2113	* @param string $complexNumber,... Series of complex numbers to add
2114	* @return string
2115	*/
2116	public static function IMSUM() {
2117	// Return value
2118	$returnValue = self::_parseComplex('0');
2119	$activeSuffix = '';
2120
2121	// Loop through the arguments
2122	$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
2123	foreach ($aArgs as $arg) {
2124	$parsedComplex = self::_parseComplex($arg);
2125
2126	if ($activeSuffix == '') {
2127	$activeSuffix = $parsedComplex['suffix'];
2128	} elseif (($parsedComplex['suffix'] != '') && ($activeSuffix != $parsedComplex['suffix'])) {
2129	return PHPExcel_Calculation_Functions::VALUE();
2130	}
2131
2132	$returnValue['real'] += $parsedComplex['real'];
2133	$returnValue['imaginary'] += $parsedComplex['imaginary'];
2134	}
2135
2136	if ($returnValue['imaginary'] == 0.0) { $activeSuffix = ''; }
2137	return self::COMPLEX($returnValue['real'],$returnValue['imaginary'],$activeSuffix);
2138	} // function IMSUM()
2139
2140
2141	/**
2142	* IMPRODUCT
2143	*
2144	* Returns the product of two or more complex numbers in x + yi or x + yj text format.
2145	*
2146	* Excel Function:
2147	* IMPRODUCT(complexNumber[,complexNumber[,...]])
2148	*
2149	* @param string $complexNumber,... Series of complex numbers to multiply
2150	* @return string
2151	*/
2152	public static function IMPRODUCT() {
2153	// Return value
2154	$returnValue = self::_parseComplex('1');
2155	$activeSuffix = '';
2156
2157	// Loop through the arguments
2158	$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
2159	foreach ($aArgs as $arg) {
2160	$parsedComplex = self::_parseComplex($arg);
2161
2162	$workValue = $returnValue;
2163	if (($parsedComplex['suffix'] != '') && ($activeSuffix == '')) {
2164	$activeSuffix = $parsedComplex['suffix'];
2165	} elseif (($parsedComplex['suffix'] != '') && ($activeSuffix != $parsedComplex['suffix'])) {
2166	return PHPExcel_Calculation_Functions::NaN();
2167	}
2168	$returnValue['real'] = ($workValue['real'] * $parsedComplex['real']) - ($workValue['imaginary'] * $parsedComplex['imaginary']);
2169	$returnValue['imaginary'] = ($workValue['real'] * $parsedComplex['imaginary']) + ($workValue['imaginary'] * $parsedComplex['real']);
2170	}
2171
2172	if ($returnValue['imaginary'] == 0.0) { $activeSuffix = ''; }
2173	return self::COMPLEX($returnValue['real'],$returnValue['imaginary'],$activeSuffix);
2174	} // function IMPRODUCT()
2175
2176
2177	/**
2178	* DELTA
2179	*
2180	* Tests whether two values are equal. Returns 1 if number1 = number2; returns 0 otherwise.
2181	* Use this function to filter a set of values. For example, by summing several DELTA
2182	* functions you calculate the count of equal pairs. This function is also known as the
2183	* Kronecker Delta function.
2184	*
2185	* Excel Function:
2186	* DELTA(a[,b])
2187	*
2188	* @param float $a The first number.
2189	* @param float $b The second number. If omitted, b is assumed to be zero.
2190	* @return int
2191	*/
2192	public static function DELTA($a, $b=0) {
2193	$a = PHPExcel_Calculation_Functions::flattenSingleValue($a);
2194	$b = PHPExcel_Calculation_Functions::flattenSingleValue($b);
2195
2196	return (int) ($a == $b);
2197	} // function DELTA()
2198
2199
2200	/**
2201	* GESTEP
2202	*
2203	* Excel Function:
2204	* GESTEP(number[,step])
2205	*
2206	* Returns 1 if number >= step; returns 0 (zero) otherwise
2207	* Use this function to filter a set of values. For example, by summing several GESTEP
2208	* functions you calculate the count of values that exceed a threshold.
2209	*
2210	* @param float $number The value to test against step.
2211	* @param float $step The threshold value.
2212	* If you omit a value for step, GESTEP uses zero.
2213	* @return int
2214	*/
2215	public static function GESTEP($number, $step=0) {
2216	$number = PHPExcel_Calculation_Functions::flattenSingleValue($number);
2217	$step = PHPExcel_Calculation_Functions::flattenSingleValue($step);
2218
2219	return (int) ($number >= $step);
2220	} // function GESTEP()
2221
2222
2223	//
2224	// Private method to calculate the erf value
2225	//
2226	private static $_two_sqrtpi = 1.128379167095512574;
2227
2228	public static function _erfVal($x) {
2229	if (abs($x) > 2.2) {
2230	return 1 - self::_erfcVal($x);
2231	}
2232	$sum = $term = $x;
2233	$xsqr = ($x * $x);
2234	$j = 1;
2235	do {
2236	$term *= $xsqr / $j;
2237	$sum -= $term / (2 * $j + 1);
2238	++$j;
2239	$term *= $xsqr / $j;
2240	$sum += $term / (2 * $j + 1);
2241	++$j;
2242	if ($sum == 0.0) {
2243	break;
2244	}
2245	} while (abs($term / $sum) > PRECISION);
2246	return self::$_two_sqrtpi * $sum;
2247	} // function _erfVal()
2248
2249
2250	/**
2251	* ERF
2252	*
2253	* Returns the error function integrated between the lower and upper bound arguments.
2254	*
2255	* Note: In Excel 2007 or earlier, if you input a negative value for the upper or lower bound arguments,
2256	* the function would return a #NUM! error. However, in Excel 2010, the function algorithm was
2257	* improved, so that it can now calculate the function for both positive and negative ranges.
2258	* PHPExcel follows Excel 2010 behaviour, and accepts nagative arguments.
2259	*
2260	* Excel Function:
2261	* ERF(lower[,upper])
2262	*
2263	* @param float $lower lower bound for integrating ERF
2264	* @param float $upper upper bound for integrating ERF.
2265	* If omitted, ERF integrates between zero and lower_limit
2266	* @return float
2267	*/
2268	public static function ERF($lower, $upper = NULL) {
2269	$lower = PHPExcel_Calculation_Functions::flattenSingleValue($lower);
2270	$upper = PHPExcel_Calculation_Functions::flattenSingleValue($upper);
2271
2272	if (is_numeric($lower)) {
2273	if (is_null($upper)) {
2274	return self::_erfVal($lower);
2275	}
2276	if (is_numeric($upper)) {
2277	return self::_erfVal($upper) - self::_erfVal($lower);
2278	}
2279	}
2280	return PHPExcel_Calculation_Functions::VALUE();
2281	} // function ERF()
2282
2283
2284	//
2285	// Private method to calculate the erfc value
2286	//
2287	private static $_one_sqrtpi = 0.564189583547756287;
2288
2289	private static function _erfcVal($x) {
2290	if (abs($x) < 2.2) {
2291	return 1 - self::_erfVal($x);
2292	}
2293	if ($x < 0) {
2294	return 2 - self::ERFC(-$x);
2295	}
2296	$a = $n = 1;
2297	$b = $c = $x;
2298	$d = ($x * $x) + 0.5;
2299	$q1 = $q2 = $b / $d;
2300	$t = 0;
2301	do {
2302	$t = $a * $n + $b * $x;
2303	$a = $b;
2304	$b = $t;
2305	$t = $c * $n + $d * $x;
2306	$c = $d;
2307	$d = $t;
2308	$n += 0.5;
2309	$q1 = $q2;
2310	$q2 = $b / $d;
2311	} while ((abs($q1 - $q2) / $q2) > PRECISION);
2312	return self::$_one_sqrtpi * exp(-$x * $x) * $q2;
2313	} // function _erfcVal()
2314
2315
2316	/**
2317	* ERFC
2318	*
2319	* Returns the complementary ERF function integrated between x and infinity
2320	*
2321	* Note: In Excel 2007 or earlier, if you input a negative value for the lower bound argument,
2322	* the function would return a #NUM! error. However, in Excel 2010, the function algorithm was
2323	* improved, so that it can now calculate the function for both positive and negative x values.
2324	* PHPExcel follows Excel 2010 behaviour, and accepts nagative arguments.
2325	*
2326	* Excel Function:
2327	* ERFC(x)
2328	*
2329	* @param float $x The lower bound for integrating ERFC
2330	* @return float
2331	*/
2332	public static function ERFC($x) {
2333	$x = PHPExcel_Calculation_Functions::flattenSingleValue($x);
2334
2335	if (is_numeric($x)) {
2336	return self::_erfcVal($x);
2337	}
2338	return PHPExcel_Calculation_Functions::VALUE();
2339	} // function ERFC()
2340
2341
2342	/**
2343	* getConversionGroups
2344	* Returns a list of the different conversion groups for UOM conversions
2345	*
2346	* @return array
2347	*/
2348	public static function getConversionGroups() {
2349	$conversionGroups = array();
2350	foreach(self::$_conversionUnits as $conversionUnit) {
2351	$conversionGroups[] = $conversionUnit['Group'];
2352	}
2353	return array_merge(array_unique($conversionGroups));
2354	} // function getConversionGroups()
2355
2356
2357	/**
2358	* getConversionGroupUnits
2359	* Returns an array of units of measure, for a specified conversion group, or for all groups
2360	*
2361	* @param string $group The group whose units of measure you want to retrieve
2362	* @return array
2363	*/
2364	public static function getConversionGroupUnits($group = NULL) {
2365	$conversionGroups = array();
2366	foreach(self::$_conversionUnits as $conversionUnit => $conversionGroup) {
2367	if ((is_null($group)) \|\| ($conversionGroup['Group'] == $group)) {
2368	$conversionGroups[$conversionGroup['Group']][] = $conversionUnit;
2369	}
2370	}
2371	return $conversionGroups;
2372	} // function getConversionGroupUnits()
2373
2374
2375	/**
2376	* getConversionGroupUnitDetails
2377	*
2378	* @param string $group The group whose units of measure you want to retrieve
2379	* @return array
2380	*/
2381	public static function getConversionGroupUnitDetails($group = NULL) {
2382	$conversionGroups = array();
2383	foreach(self::$_conversionUnits as $conversionUnit => $conversionGroup) {
2384	if ((is_null($group)) \|\| ($conversionGroup['Group'] == $group)) {
2385	$conversionGroups[$conversionGroup['Group']][] = array( 'unit' => $conversionUnit,
2386	'description' => $conversionGroup['Unit Name']
2387	);
2388	}
2389	}
2390	return $conversionGroups;
2391	} // function getConversionGroupUnitDetails()
2392
2393
2394	/**
2395	* getConversionMultipliers
2396	* Returns an array of the Multiplier prefixes that can be used with Units of Measure in CONVERTUOM()
2397	*
2398	* @return array of mixed
2399	*/
2400	public static function getConversionMultipliers() {
2401	return self::$_conversionMultipliers;
2402	} // function getConversionGroups()
2403
2404
2405	/**
2406	* CONVERTUOM
2407	*
2408	* Converts a number from one measurement system to another.
2409	* For example, CONVERT can translate a table of distances in miles to a table of distances
2410	* in kilometers.
2411	*
2412	* Excel Function:
2413	* CONVERT(value,fromUOM,toUOM)
2414	*
2415	* @param float $value The value in fromUOM to convert.
2416	* @param string $fromUOM The units for value.
2417	* @param string $toUOM The units for the result.
2418	*
2419	* @return float
2420	*/
2421	public static function CONVERTUOM($value, $fromUOM, $toUOM) {
2422	$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
2423	$fromUOM = PHPExcel_Calculation_Functions::flattenSingleValue($fromUOM);
2424	$toUOM = PHPExcel_Calculation_Functions::flattenSingleValue($toUOM);
2425
2426	if (!is_numeric($value)) {
2427	return PHPExcel_Calculation_Functions::VALUE();
2428	}
2429	$fromMultiplier = 1.0;
2430	if (isset(self::$_conversionUnits[$fromUOM])) {
2431	$unitGroup1 = self::$_conversionUnits[$fromUOM]['Group'];
2432	} else {
2433	$fromMultiplier = substr($fromUOM,0,1);
2434	$fromUOM = substr($fromUOM,1);
2435	if (isset(self::$_conversionMultipliers[$fromMultiplier])) {
2436	$fromMultiplier = self::$_conversionMultipliers[$fromMultiplier]['multiplier'];
2437	} else {
2438	return PHPExcel_Calculation_Functions::NA();
2439	}
2440	if ((isset(self::$_conversionUnits[$fromUOM])) && (self::$_conversionUnits[$fromUOM]['AllowPrefix'])) {
2441	$unitGroup1 = self::$_conversionUnits[$fromUOM]['Group'];
2442	} else {
2443	return PHPExcel_Calculation_Functions::NA();
2444	}
2445	}
2446	$value *= $fromMultiplier;
2447
2448	$toMultiplier = 1.0;
2449	if (isset(self::$_conversionUnits[$toUOM])) {
2450	$unitGroup2 = self::$_conversionUnits[$toUOM]['Group'];
2451	} else {
2452	$toMultiplier = substr($toUOM,0,1);
2453	$toUOM = substr($toUOM,1);
2454	if (isset(self::$_conversionMultipliers[$toMultiplier])) {
2455	$toMultiplier = self::$_conversionMultipliers[$toMultiplier]['multiplier'];
2456	} else {
2457	return PHPExcel_Calculation_Functions::NA();
2458	}
2459	if ((isset(self::$_conversionUnits[$toUOM])) && (self::$_conversionUnits[$toUOM]['AllowPrefix'])) {
2460	$unitGroup2 = self::$_conversionUnits[$toUOM]['Group'];
2461	} else {
2462	return PHPExcel_Calculation_Functions::NA();
2463	}
2464	}
2465	if ($unitGroup1 != $unitGroup2) {
2466	return PHPExcel_Calculation_Functions::NA();
2467	}
2468
2469	if (($fromUOM == $toUOM) && ($fromMultiplier == $toMultiplier)) {
2470	// We've already factored $fromMultiplier into the value, so we need
2471	// to reverse it again
2472	return $value / $fromMultiplier;
2473	} elseif ($unitGroup1 == 'Temperature') {
2474	if (($fromUOM == 'F') \|\| ($fromUOM == 'fah')) {
2475	if (($toUOM == 'F') \|\| ($toUOM == 'fah')) {
2476	return $value;
2477	} else {
2478	$value = (($value - 32) / 1.8);
2479	if (($toUOM == 'K') \|\| ($toUOM == 'kel')) {
2480	$value += 273.15;
2481	}
2482	return $value;
2483	}
2484	} elseif ((($fromUOM == 'K') \|\| ($fromUOM == 'kel')) &&
2485	(($toUOM == 'K') \|\| ($toUOM == 'kel'))) {
2486	return $value;
2487	} elseif ((($fromUOM == 'C') \|\| ($fromUOM == 'cel')) &&
2488	(($toUOM == 'C') \|\| ($toUOM == 'cel'))) {
2489	return $value;
2490	}
2491	if (($toUOM == 'F') \|\| ($toUOM == 'fah')) {
2492	if (($fromUOM == 'K') \|\| ($fromUOM == 'kel')) {
2493	$value -= 273.15;
2494	}
2495	return ($value * 1.8) + 32;
2496	}
2497	if (($toUOM == 'C') \|\| ($toUOM == 'cel')) {
2498	return $value - 273.15;
2499	}
2500	return $value + 273.15;
2501	}
2502	return ($value * self::$_unitConversions[$unitGroup1][$fromUOM][$toUOM]) / $toMultiplier;
2503	} // function CONVERTUOM()
2504
2505	} // class PHPExcel_Calculation_Engineering

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: sourcecode/application/libraries/PHPExcel/Calculation/Engineering.php @ 1

Download in other formats: