Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Normal
Revision Log

Engineering.php @ 461

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

File size: 96.1 KB

Rev	Line
[289]	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: pro-violet-viettel/sourcecode/application/libraries/PHPExcel/Calculation/Engineering.php @ 461

Download in other formats: