Context Navigation

source: branches/HeuristicLab.Problems.GaussianProcessTuning/ILNumerics.2.14.4735.573/Misc/ILComplex.cs @ 11194

Visit:

Last change on this file since 11194 was 9102, checked in by gkronber, 12 years ago
#1967: ILNumerics source for experimentation
File size: 102.6 KB

Rev	Line
[9102]	1	///
	2	/// This file is part of ILNumerics Community Edition.
	3	///
	4	/// ILNumerics Community Edition - high performance computing for applications.
	5	/// Copyright (C) 2006 - 2012 Haymo Kutschbach, http://ilnumerics.net
	6	///
	7	/// ILNumerics Community Edition is free software: you can redistribute it and/or modify
	8	/// it under the terms of the GNU General Public License version 3 as published by
	9	/// the Free Software Foundation.
	10	///
	11	/// ILNumerics Community Edition is distributed in the hope that it will be useful,
	12	/// but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	/// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	/// GNU General Public License for more details.
	15	///
	16	/// You should have received a copy of the GNU General Public License
	17	/// along with ILNumerics Community Edition. See the file License.txt in the root
	18	/// of your distribution package. If not, see <http://www.gnu.org/licenses/>.
	19	///
	20	/// In addition this software uses the following components and/or licenses:
	21	///
	22	/// =================================================================================
	23	/// The Open Toolkit Library License
	24	///
	25	/// Copyright (c) 2006 - 2009 the Open Toolkit library.
	26	///
	27	/// Permission is hereby granted, free of charge, to any person obtaining a copy
	28	/// of this software and associated documentation files (the "Software"), to deal
	29	/// in the Software without restriction, including without limitation the rights to
	30	/// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
	31	/// the Software, and to permit persons to whom the Software is furnished to do
	32	/// so, subject to the following conditions:
	33	///
	34	/// The above copyright notice and this permission notice shall be included in all
	35	/// copies or substantial portions of the Software.
	36	///
	37	/// =================================================================================
	38	///
	39
	40	#pragma warning disable 162
	41	using System;
	42	using System.Collections.Generic;
	43	using System.Text;
	44	using System.Runtime.InteropServices;
	45
	46
	47
	48	namespace ILNumerics {
	49	/// <summary>
	50	/// Floating point complex value data type of double precision
	51	/// </summary>
	52	/// <remarks>This class extends the system value types for real numbers to complex double
	53	/// values. Besides the publicly available members 'real' and 'imag' it provides all the
	54	/// basis functionality the floating point system.double brings (abs, log, sqrt, tan etc.),
	55	/// as well as it overrides the basic unary and binary operators for all common system value
	56	/// types including rarely used types (e.g. UInt16). This includes the basic numerical operations
	57	/// like '+','-','/','*' and the relational operators: '==','>','>=' etc. Also there are some
	58	/// explicit and some implicit casting operators from / to complex value into system
	59	/// value types.</remarks>
	60	[Serializable]
	61	[StructLayout(LayoutKind.Sequential)]
	62	public struct complex : IEquatable<complex> {
	63	/// <summary>
	64	/// Real part of this complex number
	65	/// </summary>
	66	public double real;
	67	/// <summary>
	68	/// Imaginary part of this complex number
	69	/// </summary>
	70	public double imag;
	71	/// <summary>
	72	/// Imaginary unit
	73	/// </summary>
	74	public static readonly complex i = new complex(0.0f,1.0f);
	75
	76	/// <summary>
	77	/// Constructor creating a new complex value
	78	/// </summary>
	79	/// <param name="real">Real part</param>
	80	/// <param name="imag">Imaginary part</param>
	81	public complex(double real, double imag) {
	82	this.real = real;
	83	this.imag = imag;
	84	}
	85	/// <summary>
	86	/// Complex conjugate
	87	/// </summary>
	88	public complex conj {
	89	get{
	90	return new complex(real,-imag);
	91	}
	92	}
	93
	94	/// <summary>
	95	/// Positive infinity for real and imag part of complex value
	96	/// </summary>
	97	public static complex INF {
	98	get {
	99	return new complex(
	100	double.PositiveInfinity,
	101	double.PositiveInfinity
	102	);
	103	}
	104	}
	105
	106	/// <summary>
	107	/// New complex, real and imaginary parts are zero
	108	/// </summary>
	109	public static complex Zero {
	110	get {
	111	return new complex(0.0,0.0);
	112	}
	113	}
	114
	115	/// <summary>
	116	/// Complex quantity, marked as being "not a number"
	117	/// </summary>
	118	public static complex NaN {
	119	get {
	120	return new complex(double.NaN,double.NaN);
	121	}
	122	}
	123
	124	/// <summary>
	125	/// Are obj's real and imaginary part identical to the real and imaginary parts of this fcomplex
	126	/// </summary>
	127	/// <param name="obj">fcomplex object to determine the equality for</param>
	128	/// <returns>true if obj is of fcomplex type and its real and imag part has the same
	129	/// values as the real and imaginary part of this array.</returns>
	130	public override bool Equals(object obj) {
	131	if (obj is complex && ((complex)obj) == this)
	132	return true;
	133	return false;
	134	}
	135	/// <summary>
	136	/// Check if a complex number equals this complex number
	137	/// </summary>
	138	/// <param name="other">other complex number</param>
	139	/// <returns>true if both, real and imaginary parts of both complex number are (binary) equal, false otherwise</returns>
	140	public bool Equals(complex other) {
	141	return real.Equals(other.real) && imag.Equals(other.imag);
	142	}
	143	/// <summary>
	144	/// Hash code of this comples
	145	/// </summary>
	146	/// <returns>Hash code of this complex</returns>
	147	public override int GetHashCode() {
	148	return 77101 * real.GetHashCode() + imag.GetHashCode();
	149	}
	150
	151
	152
	153	/// <summary>
	154	/// Add two complex numbers
	155	/// </summary>
	156	/// <param name="A">First summand</param>
	157	/// <param name="B">Second summand</param>
	158	/// <returns>result</returns>
	159	public static complex operator +( complex A, complex B) {
	160	complex ret;
	161	ret.real = (double) (A.real + B.real );
	162	ret.imag = (double) (A.imag + B.imag );
	163	return ret;
	164	}
	165	/// <summary>
	166	/// Subtract two complex values
	167	/// </summary>
	168	/// <param name="A">Minuend</param>
	169	/// <param name="B">Subtrahend</param>
	170	/// <returns>result</returns>
	171	public static complex operator -( complex A, complex B) {
	172	complex ret;
	173	ret.real = (double) (A.real - B.real );
	174	ret.imag = (double) (A.imag - B.imag );
	175	return ret;
	176	}
	177	/// <summary>
	178	/// Multiply two complex values
	179	/// </summary>
	180	/// <param name="A">First factor</param>
	181	/// <param name="B">Second factor</param>
	182	/// <returns>result</returns>
	183	public static complex operator *( complex A, complex B) {
	184	complex ret;
	185	ret.real = (double) ((A.real * B.real ) - (A.imag * B.imag ));
	186	ret.imag = (double) ((A.real * B.imag ) + (A.imag * B.real ));
	187	return ret;
	188	}
	189	/// <summary>
	190	/// Divide two numbers
	191	/// </summary>
	192	/// <param name="A">Divident</param>
	193	/// <param name="B">Divisor</param>
	194	/// <returns>Result</returns>
	195	/// <remarks><para>Unless the operator must handle special inputs (Inf or 0 values),
	196	/// the algorithm described in [1] is used for division. This is considered to be
	197	/// more robust against floating point overflow than the naive approach of simple
	198	/// cartesian division.</para>
	199	/// <para>References: [1]: Smith, R.L., Algorithm 116: Complex division. Commun.ACM 5,8 (1962),435 <br />
	200	/// [2]: Stewart, G.W., A note on complex division, ACM trans.on math software, Vol.11, N.3 (1985)</para></remarks>
	201	public static complex operator /( complex A, complex B) {
	202	if (B.imag == 0) return A / B.real;
	203	return A * (1 / B);
	204	if (IsNaN(A) \|\| complex .IsNaN(B)) return NaN;
	205	//if ( complex .IsInfinity(B)) return NaN;
	206	//if (A.real == 0 && A.imag == 0) return ( complex )0;
	207	complex ret;
	208	if (B.real == 0) {
	209	ret.imag = (double) -(A.real / B.imag);
	210	ret.real = (double) (A.imag / B.imag);
	211	return ret;
	212	}
	213	// this would be the naive approach. But it come with to little robustness against overflow
	214	//double norm2 = B.real * B.real + B.imag * B.imag;
	215	//if (norm2 == 0) return INF; // this may be removed, since division by 0 results in inf anyway ?
	216	//ret.real = (double) (((A.real * B.real ) + (A.imag * B.imag )) / norm2);
	217	//ret.imag = (double) (((A.imag * B.real ) - (A.real * B.imag )) / norm2);
	218
	219	// this algorithm is taken from [1]. The one described in [2] was not taken. Tests
	220	// did not show any advantage when using double precision floating point arithmetic.
	221	double tmp1, tmp2;
	222	if (Math.Abs(B.real) >= Math.Abs(B.imag)) {
	223	tmp1 = (double) (B.imag * (1/B.real));
	224	tmp2 = (double) (B.real + B.imag*tmp1);
	225	ret.real = (double) (A.real + A.imag*tmp1)/tmp2;
	226	ret.imag = (double) (A.imag - A.real*tmp1)/tmp2;
	227	} else {
	228	tmp1 = (double) (B.real * (1/B.imag));
	229	tmp2 = (double) (B.imag + B.real*tmp1);
	230	ret.real = (double) (A.imag + A.real*tmp1)/tmp2;
	231	ret.imag = - (double) (A.real - A.imag*tmp1)/tmp2;
	232	}
	233	return ret;
	234	}
	235	/// <summary>
	236	/// Equality comparison for complex numbers
	237	/// </summary>
	238	/// <param name="A">Left side</param>
	239	/// <param name="B">Right side</param>
	240	/// <returns>true, if real and imaginary part are identical</returns>
	241	public static bool operator ==( complex A, complex B) {
	242	return (A.imag == B.imag ) && (A.real == B.real );
	243	}
	244	/// <summary>
	245	/// Unequality comparison for complex numbers
	246	/// </summary>
	247	/// <param name="A">Left side</param>
	248	/// <param name="B">Right side</param>
	249	/// <returns>true if real and imaginary parts of A and B are not equal, false otherwise</returns>
	250	public static bool operator !=( complex A, complex B) {
	251	return (A.imag != B.imag ) \|\| (A.real != B.real );
	252	}
	253	/// <summary>
	254	/// Greater than comparison for complex numbers
	255	/// </summary>
	256	/// <param name="A">Left side</param>
	257	/// <param name="B">Right side</param>
	258	/// <returns>true if real part of A is greater than real part of B, false otherwise</returns>
	259	/// <remarks>Only the real parts are compared!</remarks>
	260	public static bool operator > ( complex A, complex B) {
	261	return (A.real > B.real );
	262	}
	263	/// <summary>
	264	/// Lower than comparison for complex numbers
	265	/// </summary>
	266	/// <param name="A">Left side</param>
	267	/// <param name="B">Right side</param>
	268	/// <returns>true if real part of A is lower then real part of B, false otherwise</returns>
	269	/// <remarks>Only the real parts are compared!</remarks>
	270	public static bool operator < ( complex A, complex B) {
	271	return (A.real < B.real );
	272	}
	273	/// <summary>
	274	/// Greater than or equal to comparison for complex numbers
	275	/// </summary>
	276	/// <param name="A">Left side</param>
	277	/// <param name="B">Right side</param>
	278	/// <returns>true if real part of A is greater than real part of B, false otherwise</returns>
	279	/// <remarks>Only the real parts are compared!</remarks>
	280	public static bool operator >=( complex A, complex B) {
	281	return (A.real >= B.real );
	282	}
	283	/// <summary>
	284	/// Lower than or equal to comparison for complex numbers
	285	/// </summary>
	286	/// <param name="A">Left side</param>
	287	/// <param name="B">Right side</param>
	288	/// <returns>true if real part of A is lower then real part of B, false otherwise</returns>
	289	/// <remarks>Only the real parts are compared!</remarks>
	290	public static bool operator <=( complex A, complex B) {
	291	return (A.real <= B.real );
	292	}
	293
	294	#region HYCALPER AUTO GENERATED CODE
	295
	296
	297	/// <summary>
	298	/// Add two complex numbers
	299	/// </summary>
	300	/// <param name="A">First summand</param>
	301	/// <param name="B">Second summand</param>
	302	/// <returns>result</returns>
	303	public static complex operator +( complex A, fcomplex B) {
	304	complex ret;
	305	ret.real = (double) (A.real + B.real );
	306	ret.imag = (double) (A.imag + B.imag );
	307	return ret;
	308	}
	309	/// <summary>
	310	/// Subtract two complex values
	311	/// </summary>
	312	/// <param name="A">Minuend</param>
	313	/// <param name="B">Subtrahend</param>
	314	/// <returns>result</returns>
	315	public static complex operator -( complex A, fcomplex B) {
	316	complex ret;
	317	ret.real = (double) (A.real - B.real );
	318	ret.imag = (double) (A.imag - B.imag );
	319	return ret;
	320	}
	321	/// <summary>
	322	/// Multiply two complex values
	323	/// </summary>
	324	/// <param name="A">First factor</param>
	325	/// <param name="B">Second factor</param>
	326	/// <returns>result</returns>
	327	public static complex operator *( complex A, fcomplex B) {
	328	complex ret;
	329	ret.real = (double) ((A.real * B.real ) - (A.imag * B.imag ));
	330	ret.imag = (double) ((A.real * B.imag ) + (A.imag * B.real ));
	331	return ret;
	332	}
	333	/// <summary>
	334	/// Divide two numbers
	335	/// </summary>
	336	/// <param name="A">Divident</param>
	337	/// <param name="B">Divisor</param>
	338	/// <returns>Result</returns>
	339	/// <remarks><para>Unless the operator must handle special inputs (Inf or 0 values),
	340	/// the algorithm described in [1] is used for division. This is considered to be
	341	/// more robust against floating point overflow than the naive approach of simple
	342	/// cartesian division.</para>
	343	/// <para>References: [1]: Smith, R.L., Algorithm 116: Complex division. Commun.ACM 5,8 (1962),435 <br />
	344	/// [2]: Stewart, G.W., A note on complex division, ACM trans.on math software, Vol.11, N.3 (1985)</para></remarks>
	345	public static complex operator /( complex A, fcomplex B) {
	346	if (B.imag == 0) return A / B.real;
	347	return A * (1 / B);
	348	if (IsNaN(A) \|\| fcomplex .IsNaN(B)) return NaN;
	349	//if ( fcomplex .IsInfinity(B)) return NaN;
	350	//if (A.real == 0 && A.imag == 0) return ( complex )0;
	351	complex ret;
	352	if (B.real == 0) {
	353	ret.imag = (double) -(A.real / B.imag);
	354	ret.real = (double) (A.imag / B.imag);
	355	return ret;
	356	}
	357	// this would be the naive approach. But it come with to little robustness against overflow
	358	//double norm2 = B.real * B.real + B.imag * B.imag;
	359	//if (norm2 == 0) return INF; // this may be removed, since division by 0 results in inf anyway ?
	360	//ret.real = (double) (((A.real * B.real ) + (A.imag * B.imag )) / norm2);
	361	//ret.imag = (double) (((A.imag * B.real ) - (A.real * B.imag )) / norm2);
	362
	363	// this algorithm is taken from [1]. The one described in [2] was not taken. Tests
	364	// did not show any advantage when using double precision floating point arithmetic.
	365	double tmp1, tmp2;
	366	if (Math.Abs(B.real) >= Math.Abs(B.imag)) {
	367	tmp1 = (double) (B.imag * (1/B.real));
	368	tmp2 = (double) (B.real + B.imag*tmp1);
	369	ret.real = (double) (A.real + A.imag*tmp1)/tmp2;
	370	ret.imag = (double) (A.imag - A.real*tmp1)/tmp2;
	371	} else {
	372	tmp1 = (double) (B.real * (1/B.imag));
	373	tmp2 = (double) (B.imag + B.real*tmp1);
	374	ret.real = (double) (A.imag + A.real*tmp1)/tmp2;
	375	ret.imag = - (double) (A.real - A.imag*tmp1)/tmp2;
	376	}
	377	return ret;
	378	}
	379	/// <summary>
	380	/// Equality comparison for complex numbers
	381	/// </summary>
	382	/// <param name="A">Left side</param>
	383	/// <param name="B">Right side</param>
	384	/// <returns>true, if real and imaginary part are identical</returns>
	385	public static bool operator ==( complex A, fcomplex B) {
	386	return (A.imag == B.imag ) && (A.real == B.real );
	387	}
	388	/// <summary>
	389	/// Unequality comparison for complex numbers
	390	/// </summary>
	391	/// <param name="A">Left side</param>
	392	/// <param name="B">Right side</param>
	393	/// <returns>true if real and imaginary parts of A and B are not equal, false otherwise</returns>
	394	public static bool operator !=( complex A, fcomplex B) {
	395	return (A.imag != B.imag ) \|\| (A.real != B.real );
	396	}
	397	/// <summary>
	398	/// Greater than comparison for complex numbers
	399	/// </summary>
	400	/// <param name="A">Left side</param>
	401	/// <param name="B">Right side</param>
	402	/// <returns>true if real part of A is greater than real part of B, false otherwise</returns>
	403	/// <remarks>Only the real parts are compared!</remarks>
	404	public static bool operator > ( complex A, fcomplex B) {
	405	return (A.real > B.real );
	406	}
	407	/// <summary>
	408	/// Lower than comparison for complex numbers
	409	/// </summary>
	410	/// <param name="A">Left side</param>
	411	/// <param name="B">Right side</param>
	412	/// <returns>true if real part of A is lower then real part of B, false otherwise</returns>
	413	/// <remarks>Only the real parts are compared!</remarks>
	414	public static bool operator < ( complex A, fcomplex B) {
	415	return (A.real < B.real );
	416	}
	417	/// <summary>
	418	/// Greater than or equal to comparison for complex numbers
	419	/// </summary>
	420	/// <param name="A">Left side</param>
	421	/// <param name="B">Right side</param>
	422	/// <returns>true if real part of A is greater than real part of B, false otherwise</returns>
	423	/// <remarks>Only the real parts are compared!</remarks>
	424	public static bool operator >=( complex A, fcomplex B) {
	425	return (A.real >= B.real );
	426	}
	427	/// <summary>
	428	/// Lower than or equal to comparison for complex numbers
	429	/// </summary>
	430	/// <param name="A">Left side</param>
	431	/// <param name="B">Right side</param>
	432	/// <returns>true if real part of A is lower then real part of B, false otherwise</returns>
	433	/// <remarks>Only the real parts are compared!</remarks>
	434	public static bool operator <=( complex A, fcomplex B) {
	435	return (A.real <= B.real );
	436	}
	437
	438	#endregion HYCALPER AUTO GENERATED CODE
	439
	440
	441
	442	/// <summary>
	443	/// Add two complex numbers
	444	/// </summary>
	445	/// <param name="A">First summand</param>
	446	/// <param name="B">Second summand</param>
	447	/// <returns>Result</returns>
	448	public static complex operator +( complex A, double B) {
	449	complex ret;
	450	ret.real = (double) (A.real + B);
	451	ret.imag = (double) A.imag;
	452	return ret;
	453	}
	454	/// <summary>
	455	/// Subtract two values
	456	/// </summary>
	457	/// <param name="A">Minuend</param>
	458	/// <param name="B">Subtrahend</param>
	459	/// <returns>result</returns>
	460	public static complex operator -( complex A, double B) {
	461	complex ret;
	462	ret.real = (double) (A.real - B);
	463	ret.imag = (double) A.imag;
	464	return ret;
	465	}
	466	/// <summary>
	467	/// Multiply two values
	468	/// </summary>
	469	/// <param name="A">First factor</param>
	470	/// <param name="B">Second factor</param>
	471	/// <returns>result</returns>
	472	public static complex operator *( complex A, double B) {
	473	complex ret;
	474	ret.real = (double) (A.real * B);
	475	ret.imag = (double) (A.imag * B);
	476	return ret;
	477	}
	478	/// <summary>
	479	/// Divide two numbers
	480	/// </summary>
	481	/// <param name="A">Divident</param>
	482	/// <param name="B">Divisor</param>
	483	/// <returns>result</returns>
	484	public static complex operator /( complex A, double B) {
	485	if (IsNaN(A)) return NaN;
	486
	487	if (double.IsNaN(B)) return NaN;
	488	if (A.real == 0 && A.imag == 0) {
	489	if (B == 0) return NaN;
	490	return ( complex )0;
	491	} else {
	492
	493	if (double .IsInfinity(B))
	494	{
	495	if (IsInfinity(A)) {
	496	return NaN;
	497	} else {
	498	return ( complex )0;
	499	}
	500	}
	501	}
	502	complex ret;
	503	if (B == 0) return INF ;
	504	ret.real = (double) (A.real / B);
	505	ret.imag = (double) (A.imag / B);
	506	return ret;
	507	}
	508	/// <summary>
	509	/// Equality comparison for complex numbers
	510	/// </summary>
	511	/// <param name="A">Left side</param>
	512	/// <param name="B">Right side</param>
	513	/// <returns>result</returns>
	514	/// <remarks>Real inputs are converted to a complex number and the result is compared to the complex input.</remarks>
	515	public static bool operator ==( complex A, double B) {
	516	return (A.real == B && A.imag == 0.0);
	517	}
	518	/// <summary>
	519	/// Unequality comparison for complex numbers
	520	/// </summary>
	521	/// <param name="A">Left side</param>
	522	/// <param name="B">Right side</param>
	523	/// <returns>true if real and imaginary parts of A and B are not equal, false otherwise</returns>
	524	/// <remarks>Real inputs are converted to a complex number and the result is compared to the complex input.</remarks>
	525	public static bool operator !=( complex A, double B) {
	526	return (A.imag != 0.0) \|\| (A.real != B);
	527	}
	528	/// <summary>
	529	/// Freater than comparison for complex numbers
	530	/// </summary>
	531	/// <param name="A">Left side</param>
	532	/// <param name="B">Right side</param>
	533	/// <returns>true if real part of A is greater than real part of B, false otherwise</returns>
	534	/// <remarks>Only the real parts are compared!</remarks>
	535	public static bool operator > ( complex A, double B) {
	536	return (A.real > B);
	537	}
	538	/// <summary>
	539	/// Lower than comparison for complex numbers
	540	/// </summary>
	541	/// <param name="A">Left side</param>
	542	/// <param name="B">Right side</param>
	543	/// <returns>true if real part of A is lower then real part of B, false otherwise</returns>
	544	/// <remarks>Only the real parts are compared!</remarks>
	545	public static bool operator <( complex A, double B) {
	546	return (A.real < B);
	547	}
	548	/// <summary>
	549	/// Greater than or equal to comparison for complex numbers
	550	/// </summary>
	551	/// <param name="A">Left side</param>
	552	/// <param name="B">Right side</param>
	553	/// <returns>true if real part of A is greater than real part of B, false otherwise</returns>
	554	/// <remarks>Only the real parts are compared!</remarks>
	555	public static bool operator >=( complex A, double B) {
	556	return (A.real >= B);
	557	}
	558	/// <summary>
	559	/// Lower than or equal to comparison for complex numbers
	560	/// </summary>
	561	/// <param name="A">Left side</param>
	562	/// <param name="B">Right side</param>
	563	/// <returns>true if real part of A is lower then real part of B, false otherwise</returns>
	564	/// <remarks>Only the real parts are compared!</remarks>
	565	public static bool operator <=( complex A, double B) {
	566	return (A.real <= B);
	567	}
	568
	569	#region HYCALPER AUTO GENERATED CODE
	570
	571
	572	/// <summary>
	573	/// Add two complex numbers
	574	/// </summary>
	575	/// <param name="A">First summand</param>
	576	/// <param name="B">Second summand</param>
	577	/// <returns>Result</returns>
	578	public static complex operator +( complex A, Int64 B) {
	579	complex ret;
	580	ret.real = (double) (A.real + B);
	581	ret.imag = (double) A.imag;
	582	return ret;
	583	}
	584	/// <summary>
	585	/// Subtract two values
	586	/// </summary>
	587	/// <param name="A">Minuend</param>
	588	/// <param name="B">Subtrahend</param>
	589	/// <returns>result</returns>
	590	public static complex operator -( complex A, Int64 B) {
	591	complex ret;
	592	ret.real = (double) (A.real - B);
	593	ret.imag = (double) A.imag;
	594	return ret;
	595	}
	596	/// <summary>
	597	/// Multiply two values
	598	/// </summary>
	599	/// <param name="A">First factor</param>
	600	/// <param name="B">Second factor</param>
	601	/// <returns>result</returns>
	602	public static complex operator *( complex A, Int64 B) {
	603	complex ret;
	604	ret.real = (double) (A.real * B);
	605	ret.imag = (double) (A.imag * B);
	606	return ret;
	607	}
	608	/// <summary>
	609	/// Divide two numbers
	610	/// </summary>
	611	/// <param name="A">Divident</param>
	612	/// <param name="B">Divisor</param>
	613	/// <returns>result</returns>
	614	public static complex operator /( complex A, Int64 B) {
	615	if (IsNaN(A)) return NaN;
	616
	617	if (A.real == 0 && A.imag == 0) {
	618	if (B == 0) return NaN;
	619	return ( complex )0;
	620	} else {
	621	if (false)
	622	{
	623	if (IsInfinity(A)) {
	624	return NaN;
	625	} else {
	626	return ( complex )0;
	627	}
	628	}
	629	}
	630	complex ret;
	631	if (B == 0) return INF ;
	632	ret.real = (double) (A.real / B);
	633	ret.imag = (double) (A.imag / B);
	634	return ret;
	635	}
	636	/// <summary>
	637	/// Equality comparison for complex numbers
	638	/// </summary>
	639	/// <param name="A">Left side</param>
	640	/// <param name="B">Right side</param>
	641	/// <returns>result</returns>
	642	/// <remarks>Real inputs are converted to a complex number and the result is compared to the complex input.</remarks>
	643	public static bool operator ==( complex A, Int64 B) {
	644	return (A.real == B && A.imag == 0.0);
	645	}
	646	/// <summary>
	647	/// Unequality comparison for complex numbers
	648	/// </summary>
	649	/// <param name="A">Left side</param>
	650	/// <param name="B">Right side</param>
	651	/// <returns>true if real and imaginary parts of A and B are not equal, false otherwise</returns>
	652	/// <remarks>Real inputs are converted to a complex number and the result is compared to the complex input.</remarks>
	653	public static bool operator !=( complex A, Int64 B) {
	654	return (A.imag != 0.0) \|\| (A.real != B);
	655	}
	656	/// <summary>
	657	/// Freater than comparison for complex numbers
	658	/// </summary>
	659	/// <param name="A">Left side</param>
	660	/// <param name="B">Right side</param>
	661	/// <returns>true if real part of A is greater than real part of B, false otherwise</returns>
	662	/// <remarks>Only the real parts are compared!</remarks>
	663	public static bool operator > ( complex A, Int64 B) {
	664	return (A.real > B);
	665	}
	666	/// <summary>
	667	/// Lower than comparison for complex numbers
	668	/// </summary>
	669	/// <param name="A">Left side</param>
	670	/// <param name="B">Right side</param>
	671	/// <returns>true if real part of A is lower then real part of B, false otherwise</returns>
	672	/// <remarks>Only the real parts are compared!</remarks>
	673	public static bool operator <( complex A, Int64 B) {
	674	return (A.real < B);
	675	}
	676	/// <summary>
	677	/// Greater than or equal to comparison for complex numbers
	678	/// </summary>
	679	/// <param name="A">Left side</param>
	680	/// <param name="B">Right side</param>
	681	/// <returns>true if real part of A is greater than real part of B, false otherwise</returns>
	682	/// <remarks>Only the real parts are compared!</remarks>
	683	public static bool operator >=( complex A, Int64 B) {
	684	return (A.real >= B);
	685	}
	686	/// <summary>
	687	/// Lower than or equal to comparison for complex numbers
	688	/// </summary>
	689	/// <param name="A">Left side</param>
	690	/// <param name="B">Right side</param>
	691	/// <returns>true if real part of A is lower then real part of B, false otherwise</returns>
	692	/// <remarks>Only the real parts are compared!</remarks>
	693	public static bool operator <=( complex A, Int64 B) {
	694	return (A.real <= B);
	695	}
	696
	697	/// <summary>
	698	/// Add two complex numbers
	699	/// </summary>
	700	/// <param name="A">First summand</param>
	701	/// <param name="B">Second summand</param>
	702	/// <returns>Result</returns>
	703	public static complex operator +( complex A, Int32 B) {
	704	complex ret;
	705	ret.real = (double) (A.real + B);
	706	ret.imag = (double) A.imag;
	707	return ret;
	708	}
	709	/// <summary>
	710	/// Subtract two values
	711	/// </summary>
	712	/// <param name="A">Minuend</param>
	713	/// <param name="B">Subtrahend</param>
	714	/// <returns>result</returns>
	715	public static complex operator -( complex A, Int32 B) {
	716	complex ret;
	717	ret.real = (double) (A.real - B);
	718	ret.imag = (double) A.imag;
	719	return ret;
	720	}
	721	/// <summary>
	722	/// Multiply two values
	723	/// </summary>
	724	/// <param name="A">First factor</param>
	725	/// <param name="B">Second factor</param>
	726	/// <returns>result</returns>
	727	public static complex operator *( complex A, Int32 B) {
	728	complex ret;
	729	ret.real = (double) (A.real * B);
	730	ret.imag = (double) (A.imag * B);
	731	return ret;
	732	}
	733	/// <summary>
	734	/// Divide two numbers
	735	/// </summary>
	736	/// <param name="A">Divident</param>
	737	/// <param name="B">Divisor</param>
	738	/// <returns>result</returns>
	739	public static complex operator /( complex A, Int32 B) {
	740	if (IsNaN(A)) return NaN;
	741
	742	if (A.real == 0 && A.imag == 0) {
	743	if (B == 0) return NaN;
	744	return ( complex )0;
	745	} else {
	746	if (false)
	747	{
	748	if (IsInfinity(A)) {
	749	return NaN;
	750	} else {
	751	return ( complex )0;
	752	}
	753	}
	754	}
	755	complex ret;
	756	if (B == 0) return INF ;
	757	ret.real = (double) (A.real / B);
	758	ret.imag = (double) (A.imag / B);
	759	return ret;
	760	}
	761	/// <summary>
	762	/// Equality comparison for complex numbers
	763	/// </summary>
	764	/// <param name="A">Left side</param>
	765	/// <param name="B">Right side</param>
	766	/// <returns>result</returns>
	767	/// <remarks>Real inputs are converted to a complex number and the result is compared to the complex input.</remarks>
	768	public static bool operator ==( complex A, Int32 B) {
	769	return (A.real == B && A.imag == 0.0);
	770	}
	771	/// <summary>
	772	/// Unequality comparison for complex numbers
	773	/// </summary>
	774	/// <param name="A">Left side</param>
	775	/// <param name="B">Right side</param>
	776	/// <returns>true if real and imaginary parts of A and B are not equal, false otherwise</returns>
	777	/// <remarks>Real inputs are converted to a complex number and the result is compared to the complex input.</remarks>
	778	public static bool operator !=( complex A, Int32 B) {
	779	return (A.imag != 0.0) \|\| (A.real != B);
	780	}
	781	/// <summary>
	782	/// Freater than comparison for complex numbers
	783	/// </summary>
	784	/// <param name="A">Left side</param>
	785	/// <param name="B">Right side</param>
	786	/// <returns>true if real part of A is greater than real part of B, false otherwise</returns>
	787	/// <remarks>Only the real parts are compared!</remarks>
	788	public static bool operator > ( complex A, Int32 B) {
	789	return (A.real > B);
	790	}
	791	/// <summary>
	792	/// Lower than comparison for complex numbers
	793	/// </summary>
	794	/// <param name="A">Left side</param>
	795	/// <param name="B">Right side</param>
	796	/// <returns>true if real part of A is lower then real part of B, false otherwise</returns>
	797	/// <remarks>Only the real parts are compared!</remarks>
	798	public static bool operator <( complex A, Int32 B) {
	799	return (A.real < B);
	800	}
	801	/// <summary>
	802	/// Greater than or equal to comparison for complex numbers
	803	/// </summary>
	804	/// <param name="A">Left side</param>
	805	/// <param name="B">Right side</param>
	806	/// <returns>true if real part of A is greater than real part of B, false otherwise</returns>
	807	/// <remarks>Only the real parts are compared!</remarks>
	808	public static bool operator >=( complex A, Int32 B) {
	809	return (A.real >= B);
	810	}
	811	/// <summary>
	812	/// Lower than or equal to comparison for complex numbers
	813	/// </summary>
	814	/// <param name="A">Left side</param>
	815	/// <param name="B">Right side</param>
	816	/// <returns>true if real part of A is lower then real part of B, false otherwise</returns>
	817	/// <remarks>Only the real parts are compared!</remarks>
	818	public static bool operator <=( complex A, Int32 B) {
	819	return (A.real <= B);
	820	}
	821
	822	/// <summary>
	823	/// Add two complex numbers
	824	/// </summary>
	825	/// <param name="A">First summand</param>
	826	/// <param name="B">Second summand</param>
	827	/// <returns>Result</returns>
	828	public static complex operator +( complex A, float B) {
	829	complex ret;
	830	ret.real = (double) (A.real + B);
	831	ret.imag = (double) A.imag;
	832	return ret;
	833	}
	834	/// <summary>
	835	/// Subtract two values
	836	/// </summary>
	837	/// <param name="A">Minuend</param>
	838	/// <param name="B">Subtrahend</param>
	839	/// <returns>result</returns>
	840	public static complex operator -( complex A, float B) {
	841	complex ret;
	842	ret.real = (double) (A.real - B);
	843	ret.imag = (double) A.imag;
	844	return ret;
	845	}
	846	/// <summary>
	847	/// Multiply two values
	848	/// </summary>
	849	/// <param name="A">First factor</param>
	850	/// <param name="B">Second factor</param>
	851	/// <returns>result</returns>
	852	public static complex operator *( complex A, float B) {
	853	complex ret;
	854	ret.real = (double) (A.real * B);
	855	ret.imag = (double) (A.imag * B);
	856	return ret;
	857	}
	858	/// <summary>
	859	/// Divide two numbers
	860	/// </summary>
	861	/// <param name="A">Divident</param>
	862	/// <param name="B">Divisor</param>
	863	/// <returns>result</returns>
	864	public static complex operator /( complex A, float B) {
	865	if (IsNaN(A)) return NaN;
	866	if (float.IsNaN(B)) return NaN;
	867	if (A.real == 0 && A.imag == 0) {
	868	if (B == 0) return NaN;
	869	return ( complex )0;
	870	} else {
	871	if (float.IsInfinity(B))
	872	{
	873	if (IsInfinity(A)) {
	874	return NaN;
	875	} else {
	876	return ( complex )0;
	877	}
	878	}
	879	}
	880	complex ret;
	881	if (B == 0) return INF ;
	882	ret.real = (double) (A.real / B);
	883	ret.imag = (double) (A.imag / B);
	884	return ret;
	885	}
	886	/// <summary>
	887	/// Equality comparison for complex numbers
	888	/// </summary>
	889	/// <param name="A">Left side</param>
	890	/// <param name="B">Right side</param>
	891	/// <returns>result</returns>
	892	/// <remarks>Real inputs are converted to a complex number and the result is compared to the complex input.</remarks>
	893	public static bool operator ==( complex A, float B) {
	894	return (A.real == B && A.imag == 0.0);
	895	}
	896	/// <summary>
	897	/// Unequality comparison for complex numbers
	898	/// </summary>
	899	/// <param name="A">Left side</param>
	900	/// <param name="B">Right side</param>
	901	/// <returns>true if real and imaginary parts of A and B are not equal, false otherwise</returns>
	902	/// <remarks>Real inputs are converted to a complex number and the result is compared to the complex input.</remarks>
	903	public static bool operator !=( complex A, float B) {
	904	return (A.imag != 0.0) \|\| (A.real != B);
	905	}
	906	/// <summary>
	907	/// Freater than comparison for complex numbers
	908	/// </summary>
	909	/// <param name="A">Left side</param>
	910	/// <param name="B">Right side</param>
	911	/// <returns>true if real part of A is greater than real part of B, false otherwise</returns>
	912	/// <remarks>Only the real parts are compared!</remarks>
	913	public static bool operator > ( complex A, float B) {
	914	return (A.real > B);
	915	}
	916	/// <summary>
	917	/// Lower than comparison for complex numbers
	918	/// </summary>
	919	/// <param name="A">Left side</param>
	920	/// <param name="B">Right side</param>
	921	/// <returns>true if real part of A is lower then real part of B, false otherwise</returns>
	922	/// <remarks>Only the real parts are compared!</remarks>
	923	public static bool operator <( complex A, float B) {
	924	return (A.real < B);
	925	}
	926	/// <summary>
	927	/// Greater than or equal to comparison for complex numbers
	928	/// </summary>
	929	/// <param name="A">Left side</param>
	930	/// <param name="B">Right side</param>
	931	/// <returns>true if real part of A is greater than real part of B, false otherwise</returns>
	932	/// <remarks>Only the real parts are compared!</remarks>
	933	public static bool operator >=( complex A, float B) {
	934	return (A.real >= B);
	935	}
	936	/// <summary>
	937	/// Lower than or equal to comparison for complex numbers
	938	/// </summary>
	939	/// <param name="A">Left side</param>
	940	/// <param name="B">Right side</param>
	941	/// <returns>true if real part of A is lower then real part of B, false otherwise</returns>
	942	/// <remarks>Only the real parts are compared!</remarks>
	943	public static bool operator <=( complex A, float B) {
	944	return (A.real <= B);
	945	}
	946
	947	/// <summary>
	948	/// Add two complex numbers
	949	/// </summary>
	950	/// <param name="A">First summand</param>
	951	/// <param name="B">Second summand</param>
	952	/// <returns>Result</returns>
	953	public static complex operator +( complex A, byte B) {
	954	complex ret;
	955	ret.real = (double) (A.real + B);
	956	ret.imag = (double) A.imag;
	957	return ret;
	958	}
	959	/// <summary>
	960	/// Subtract two values
	961	/// </summary>
	962	/// <param name="A">Minuend</param>
	963	/// <param name="B">Subtrahend</param>
	964	/// <returns>result</returns>
	965	public static complex operator -( complex A, byte B) {
	966	complex ret;
	967	ret.real = (double) (A.real - B);
	968	ret.imag = (double) A.imag;
	969	return ret;
	970	}
	971	/// <summary>
	972	/// Multiply two values
	973	/// </summary>
	974	/// <param name="A">First factor</param>
	975	/// <param name="B">Second factor</param>
	976	/// <returns>result</returns>
	977	public static complex operator *( complex A, byte B) {
	978	complex ret;
	979	ret.real = (double) (A.real * B);
	980	ret.imag = (double) (A.imag * B);
	981	return ret;
	982	}
	983	/// <summary>
	984	/// Divide two numbers
	985	/// </summary>
	986	/// <param name="A">Divident</param>
	987	/// <param name="B">Divisor</param>
	988	/// <returns>result</returns>
	989	public static complex operator /( complex A, byte B) {
	990	if (IsNaN(A)) return NaN;
	991
	992	if (A.real == 0 && A.imag == 0) {
	993	if (B == 0) return NaN;
	994	return ( complex )0;
	995	} else {
	996	if (false)
	997	{
	998	if (IsInfinity(A)) {
	999	return NaN;
	1000	} else {
	1001	return ( complex )0;
	1002	}
	1003	}
	1004	}
	1005	complex ret;
	1006	if (B == 0) return INF ;
	1007	ret.real = (double) (A.real / B);
	1008	ret.imag = (double) (A.imag / B);
	1009	return ret;
	1010	}
	1011	/// <summary>
	1012	/// Equality comparison for complex numbers
	1013	/// </summary>
	1014	/// <param name="A">Left side</param>
	1015	/// <param name="B">Right side</param>
	1016	/// <returns>result</returns>
	1017	/// <remarks>Real inputs are converted to a complex number and the result is compared to the complex input.</remarks>
	1018	public static bool operator ==( complex A, byte B) {
	1019	return (A.real == B && A.imag == 0.0);
	1020	}
	1021	/// <summary>
	1022	/// Unequality comparison for complex numbers
	1023	/// </summary>
	1024	/// <param name="A">Left side</param>
	1025	/// <param name="B">Right side</param>
	1026	/// <returns>true if real and imaginary parts of A and B are not equal, false otherwise</returns>
	1027	/// <remarks>Real inputs are converted to a complex number and the result is compared to the complex input.</remarks>
	1028	public static bool operator !=( complex A, byte B) {
	1029	return (A.imag != 0.0) \|\| (A.real != B);
	1030	}
	1031	/// <summary>
	1032	/// Freater than comparison for complex numbers
	1033	/// </summary>
	1034	/// <param name="A">Left side</param>
	1035	/// <param name="B">Right side</param>
	1036	/// <returns>true if real part of A is greater than real part of B, false otherwise</returns>
	1037	/// <remarks>Only the real parts are compared!</remarks>
	1038	public static bool operator > ( complex A, byte B) {
	1039	return (A.real > B);
	1040	}
	1041	/// <summary>
	1042	/// Lower than comparison for complex numbers
	1043	/// </summary>
	1044	/// <param name="A">Left side</param>
	1045	/// <param name="B">Right side</param>
	1046	/// <returns>true if real part of A is lower then real part of B, false otherwise</returns>
	1047	/// <remarks>Only the real parts are compared!</remarks>
	1048	public static bool operator <( complex A, byte B) {
	1049	return (A.real < B);
	1050	}
	1051	/// <summary>
	1052	/// Greater than or equal to comparison for complex numbers
	1053	/// </summary>
	1054	/// <param name="A">Left side</param>
	1055	/// <param name="B">Right side</param>
	1056	/// <returns>true if real part of A is greater than real part of B, false otherwise</returns>
	1057	/// <remarks>Only the real parts are compared!</remarks>
	1058	public static bool operator >=( complex A, byte B) {
	1059	return (A.real >= B);
	1060	}
	1061	/// <summary>
	1062	/// Lower than or equal to comparison for complex numbers
	1063	/// </summary>
	1064	/// <param name="A">Left side</param>
	1065	/// <param name="B">Right side</param>
	1066	/// <returns>true if real part of A is lower then real part of B, false otherwise</returns>
	1067	/// <remarks>Only the real parts are compared!</remarks>
	1068	public static bool operator <=( complex A, byte B) {
	1069	return (A.real <= B);
	1070	}
	1071
	1072	#endregion HYCALPER AUTO GENERATED CODE
	1073
	1074
	1075
	1076	/// <summary>
	1077	/// Add two complex values
	1078	/// </summary>
	1079	/// <param name="A">First summand</param>
	1080	/// <param name="B">Second summand</param>
	1081	/// <returns>Result</returns>
	1082	public static complex operator +( double A, complex B) {
	1083	complex ret;
	1084	ret.real = (double) (A + B.real);
	1085	ret.imag = (double) B.imag;
	1086	return ret;
	1087	}
	1088	/// <summary>
	1089	/// Subtract two values
	1090	/// </summary>
	1091	/// <param name="A">Minuend</param>
	1092	/// <param name="B">Subtrahend</param>
	1093	/// <returns>Result</returns>
	1094	public static complex operator -( double A, complex B) {
	1095	complex ret;
	1096	ret.real = (double) (A - B.real);
	1097	ret.imag = - (double) B.imag;
	1098	return ret;
	1099	}
	1100	/// <summary>
	1101	/// Multiply two values
	1102	/// </summary>
	1103	/// <param name="A">First factor</param>
	1104	/// <param name="B">Second factor</param>
	1105	/// <returns>Result</returns>
	1106	public static complex operator *( double A, complex B) {
	1107	complex ret;
	1108	ret.real = (double) (A * B.real);
	1109	ret.imag = (double) (A * B.imag);
	1110	return ret;
	1111	}
	1112	/// <summary>
	1113	/// Divide two values
	1114	/// </summary>
	1115	/// <param name="A">Divident</param>
	1116	/// <param name="B">Divisor</param>
	1117	/// <returns>Result</returns>
	1118	public static complex operator /( double A, complex B) {
	1119	complex ret;
	1120	if (A == 0) {
	1121	if (IsInfinity(B)) return NaN;
	1122	} else {
	1123	if (IsInfinity(B)) return ( complex )0;
	1124	}
	1125	if (B.real == 0 && B.imag == 0) {
	1126	return INF;
	1127	}
	1128	// this algorithm is taken from [1]. The one described in [2] was not taken. Tests
	1129	// did not show any advantage when using double precision floating point arithmetic.
	1130	double tmp;
	1131	if (Math.Abs(B.real) >= Math.Abs(B.imag)) {
	1132	tmp = (double) (B.imag * (1/B.real));
	1133	ret.imag = (double) (B.real + B.imag*tmp);
	1134	ret.real = (double) A/ret.imag;
	1135	ret.imag = - (double) (A*tmp)/ret.imag;
	1136	} else {
	1137	tmp = (double) (B.real * (1/B.imag));
	1138	ret.imag = (double) (B.imag + B.real*tmp);
	1139	ret.real = (double) (A*tmp)/ret.imag;
	1140	ret.imag = - (double) A/ret.imag;
	1141	}
	1142	return ret;
	1143	}
	1144	/// <summary>
	1145	/// Equality comparison for complex numbers
	1146	/// </summary>
	1147	/// <param name="A">Left side</param>
	1148	/// <param name="B">Right side</param>
	1149	/// <returns>Result</returns>
	1150	/// <remarks>Real inputs are converted to a complex number and the result is compared to the complex input.</remarks>
	1151	public static bool operator ==( double A, complex B) {
	1152	return (B.real == A && B.imag == 0.0);
	1153	}
	1154	/// <summary>
	1155	/// Unequality comparison for complex numbers
	1156	/// </summary>
	1157	/// <param name="A">Left side</param>
	1158	/// <param name="B">Right side</param>
	1159	/// <returns>true if real and imaginary parts of A and B are not equal, false otherwise</returns>
	1160	/// <remarks>Real inputs are converted to a complex number and the result is compared to the complex input.</remarks>
	1161	public static bool operator !=( double A, complex B) {
	1162	return (B.imag != 0.0) \|\| (B.real != A);
	1163	}
	1164	/// <summary>
	1165	/// Greater than comparison for complex numbers
	1166	/// </summary>
	1167	/// <param name="A">Left side</param>
	1168	/// <param name="B">Right side</param>
	1169	/// <returns>true if real part of A is greater than real part of B, false otherwise</returns>
	1170	/// <remarks>Only the real parts are compared!</remarks>
	1171	public static bool operator > ( double A, complex B) {
	1172	return (A > B.real);
	1173	}
	1174	/// <summary>
	1175	/// Lower than comparison for complex numbers
	1176	/// </summary>
	1177	/// <param name="A">Left side</param>
	1178	/// <param name="B">Right side</param>
	1179	/// <returns>true if real part of A is lower then real part of B, false otherwise</returns>
	1180	/// <remarks>Only the real parts are compared!</remarks>
	1181	public static bool operator < ( double A, complex B) {
	1182	return (A < B.real);
	1183	}
	1184	/// <summary>
	1185	/// Greater than or equal to comparison for complex numbers
	1186	/// </summary>
	1187	/// <param name="A">Left side</param>
	1188	/// <param name="B">Right side</param>
	1189	/// <returns>true if real part of A is greater than real part of B, false otherwise</returns>
	1190	/// <remarks>Only the real parts are compared!</remarks>
	1191	public static bool operator >=( double A, complex B) {
	1192	return (A >= B.real);
	1193	}
	1194	/// <summary>
	1195	/// Lower than or equal to comparison for complex numbers
	1196	/// </summary>
	1197	/// <param name="A">Left side</param>
	1198	/// <param name="B">Right side</param>
	1199	/// <returns>true if real part of A is lower then real part of B, false otherwise</returns>
	1200	/// <remarks>Only the real parts are compared!</remarks>
	1201	public static bool operator <=( double A, complex B) {
	1202	return (A <= B.real);
	1203	}
	1204
	1205	#region HYCALPER AUTO GENERATED CODE
	1206
	1207
	1208	/// <summary>
	1209	/// Add two complex values
	1210	/// </summary>
	1211	/// <param name="A">First summand</param>
	1212	/// <param name="B">Second summand</param>
	1213	/// <returns>Result</returns>
	1214	public static complex operator +( Int64 A, complex B) {
	1215	complex ret;
	1216	ret.real = (double) (A + B.real);
	1217	ret.imag = (double) B.imag;
	1218	return ret;
	1219	}
	1220	/// <summary>
	1221	/// Subtract two values
	1222	/// </summary>
	1223	/// <param name="A">Minuend</param>
	1224	/// <param name="B">Subtrahend</param>
	1225	/// <returns>Result</returns>
	1226	public static complex operator -( Int64 A, complex B) {
	1227	complex ret;
	1228	ret.real = (double) (A - B.real);
	1229	ret.imag = - (double) B.imag;
	1230	return ret;
	1231	}
	1232	/// <summary>
	1233	/// Multiply two values
	1234	/// </summary>
	1235	/// <param name="A">First factor</param>
	1236	/// <param name="B">Second factor</param>
	1237	/// <returns>Result</returns>
	1238	public static complex operator *( Int64 A, complex B) {
	1239	complex ret;
	1240	ret.real = (double) (A * B.real);
	1241	ret.imag = (double) (A * B.imag);
	1242	return ret;
	1243	}
	1244	/// <summary>
	1245	/// Divide two values
	1246	/// </summary>
	1247	/// <param name="A">Divident</param>
	1248	/// <param name="B">Divisor</param>
	1249	/// <returns>Result</returns>
	1250	public static complex operator /( Int64 A, complex B) {
	1251	complex ret;
	1252	if (A == 0) {
	1253	if (IsInfinity(B)) return NaN;
	1254	} else {
	1255	if (IsInfinity(B)) return ( complex )0;
	1256	}
	1257	if (B.real == 0 && B.imag == 0) {
	1258	return INF;
	1259	}
	1260	// this algorithm is taken from [1]. The one described in [2] was not taken. Tests
	1261	// did not show any advantage when using double precision floating point arithmetic.
	1262	double tmp;
	1263	if (Math.Abs(B.real) >= Math.Abs(B.imag)) {
	1264	tmp = (double) (B.imag * (1/B.real));
	1265	ret.imag = (double) (B.real + B.imag*tmp);
	1266	ret.real = (double) A/ret.imag;
	1267	ret.imag = - (double) (A*tmp)/ret.imag;
	1268	} else {
	1269	tmp = (double) (B.real * (1/B.imag));
	1270	ret.imag = (double) (B.imag + B.real*tmp);
	1271	ret.real = (double) (A*tmp)/ret.imag;
	1272	ret.imag = - (double) A/ret.imag;
	1273	}
	1274	return ret;
	1275	}
	1276	/// <summary>
	1277	/// Equality comparison for complex numbers
	1278	/// </summary>
	1279	/// <param name="A">Left side</param>
	1280	/// <param name="B">Right side</param>
	1281	/// <returns>Result</returns>
	1282	/// <remarks>Real inputs are converted to a complex number and the result is compared to the complex input.</remarks>
	1283	public static bool operator ==( Int64 A, complex B) {
	1284	return (B.real == A && B.imag == 0.0);
	1285	}
	1286	/// <summary>
	1287	/// Unequality comparison for complex numbers
	1288	/// </summary>
	1289	/// <param name="A">Left side</param>
	1290	/// <param name="B">Right side</param>
	1291	/// <returns>true if real and imaginary parts of A and B are not equal, false otherwise</returns>
	1292	/// <remarks>Real inputs are converted to a complex number and the result is compared to the complex input.</remarks>
	1293	public static bool operator !=( Int64 A, complex B) {
	1294	return (B.imag != 0.0) \|\| (B.real != A);
	1295	}
	1296	/// <summary>
	1297	/// Greater than comparison for complex numbers
	1298	/// </summary>
	1299	/// <param name="A">Left side</param>
	1300	/// <param name="B">Right side</param>
	1301	/// <returns>true if real part of A is greater than real part of B, false otherwise</returns>
	1302	/// <remarks>Only the real parts are compared!</remarks>
	1303	public static bool operator > ( Int64 A, complex B) {
	1304	return (A > B.real);
	1305	}
	1306	/// <summary>
	1307	/// Lower than comparison for complex numbers
	1308	/// </summary>
	1309	/// <param name="A">Left side</param>
	1310	/// <param name="B">Right side</param>
	1311	/// <returns>true if real part of A is lower then real part of B, false otherwise</returns>
	1312	/// <remarks>Only the real parts are compared!</remarks>
	1313	public static bool operator < ( Int64 A, complex B) {
	1314	return (A < B.real);
	1315	}
	1316	/// <summary>
	1317	/// Greater than or equal to comparison for complex numbers
	1318	/// </summary>
	1319	/// <param name="A">Left side</param>
	1320	/// <param name="B">Right side</param>
	1321	/// <returns>true if real part of A is greater than real part of B, false otherwise</returns>
	1322	/// <remarks>Only the real parts are compared!</remarks>
	1323	public static bool operator >=( Int64 A, complex B) {
	1324	return (A >= B.real);
	1325	}
	1326	/// <summary>
	1327	/// Lower than or equal to comparison for complex numbers
	1328	/// </summary>
	1329	/// <param name="A">Left side</param>
	1330	/// <param name="B">Right side</param>
	1331	/// <returns>true if real part of A is lower then real part of B, false otherwise</returns>
	1332	/// <remarks>Only the real parts are compared!</remarks>
	1333	public static bool operator <=( Int64 A, complex B) {
	1334	return (A <= B.real);
	1335	}
	1336
	1337	/// <summary>
	1338	/// Add two complex values
	1339	/// </summary>
	1340	/// <param name="A">First summand</param>
	1341	/// <param name="B">Second summand</param>
	1342	/// <returns>Result</returns>
	1343	public static complex operator +( Int32 A, complex B) {
	1344	complex ret;
	1345	ret.real = (double) (A + B.real);
	1346	ret.imag = (double) B.imag;
	1347	return ret;
	1348	}
	1349	/// <summary>
	1350	/// Subtract two values
	1351	/// </summary>
	1352	/// <param name="A">Minuend</param>
	1353	/// <param name="B">Subtrahend</param>
	1354	/// <returns>Result</returns>
	1355	public static complex operator -( Int32 A, complex B) {
	1356	complex ret;
	1357	ret.real = (double) (A - B.real);
	1358	ret.imag = - (double) B.imag;
	1359	return ret;
	1360	}
	1361	/// <summary>
	1362	/// Multiply two values
	1363	/// </summary>
	1364	/// <param name="A">First factor</param>
	1365	/// <param name="B">Second factor</param>
	1366	/// <returns>Result</returns>
	1367	public static complex operator *( Int32 A, complex B) {
	1368	complex ret;
	1369	ret.real = (double) (A * B.real);
	1370	ret.imag = (double) (A * B.imag);
	1371	return ret;
	1372	}
	1373	/// <summary>
	1374	/// Divide two values
	1375	/// </summary>
	1376	/// <param name="A">Divident</param>
	1377	/// <param name="B">Divisor</param>
	1378	/// <returns>Result</returns>
	1379	public static complex operator /( Int32 A, complex B) {
	1380	complex ret;
	1381	if (A == 0) {
	1382	if (IsInfinity(B)) return NaN;
	1383	} else {
	1384	if (IsInfinity(B)) return ( complex )0;
	1385	}
	1386	if (B.real == 0 && B.imag == 0) {
	1387	return INF;
	1388	}
	1389	// this algorithm is taken from [1]. The one described in [2] was not taken. Tests
	1390	// did not show any advantage when using double precision floating point arithmetic.
	1391	double tmp;
	1392	if (Math.Abs(B.real) >= Math.Abs(B.imag)) {
	1393	tmp = (double) (B.imag * (1/B.real));
	1394	ret.imag = (double) (B.real + B.imag*tmp);
	1395	ret.real = (double) A/ret.imag;
	1396	ret.imag = - (double) (A*tmp)/ret.imag;
	1397	} else {
	1398	tmp = (double) (B.real * (1/B.imag));
	1399	ret.imag = (double) (B.imag + B.real*tmp);
	1400	ret.real = (double) (A*tmp)/ret.imag;
	1401	ret.imag = - (double) A/ret.imag;
	1402	}
	1403	return ret;
	1404	}
	1405	/// <summary>
	1406	/// Equality comparison for complex numbers
	1407	/// </summary>
	1408	/// <param name="A">Left side</param>
	1409	/// <param name="B">Right side</param>
	1410	/// <returns>Result</returns>
	1411	/// <remarks>Real inputs are converted to a complex number and the result is compared to the complex input.</remarks>
	1412	public static bool operator ==( Int32 A, complex B) {
	1413	return (B.real == A && B.imag == 0.0);
	1414	}
	1415	/// <summary>
	1416	/// Unequality comparison for complex numbers
	1417	/// </summary>
	1418	/// <param name="A">Left side</param>
	1419	/// <param name="B">Right side</param>
	1420	/// <returns>true if real and imaginary parts of A and B are not equal, false otherwise</returns>
	1421	/// <remarks>Real inputs are converted to a complex number and the result is compared to the complex input.</remarks>
	1422	public static bool operator !=( Int32 A, complex B) {
	1423	return (B.imag != 0.0) \|\| (B.real != A);
	1424	}
	1425	/// <summary>
	1426	/// Greater than comparison for complex numbers
	1427	/// </summary>
	1428	/// <param name="A">Left side</param>
	1429	/// <param name="B">Right side</param>
	1430	/// <returns>true if real part of A is greater than real part of B, false otherwise</returns>
	1431	/// <remarks>Only the real parts are compared!</remarks>
	1432	public static bool operator > ( Int32 A, complex B) {
	1433	return (A > B.real);
	1434	}
	1435	/// <summary>
	1436	/// Lower than comparison for complex numbers
	1437	/// </summary>
	1438	/// <param name="A">Left side</param>
	1439	/// <param name="B">Right side</param>
	1440	/// <returns>true if real part of A is lower then real part of B, false otherwise</returns>
	1441	/// <remarks>Only the real parts are compared!</remarks>
	1442	public static bool operator < ( Int32 A, complex B) {
	1443	return (A < B.real);
	1444	}
	1445	/// <summary>
	1446	/// Greater than or equal to comparison for complex numbers
	1447	/// </summary>
	1448	/// <param name="A">Left side</param>
	1449	/// <param name="B">Right side</param>
	1450	/// <returns>true if real part of A is greater than real part of B, false otherwise</returns>
	1451	/// <remarks>Only the real parts are compared!</remarks>
	1452	public static bool operator >=( Int32 A, complex B) {
	1453	return (A >= B.real);
	1454	}
	1455	/// <summary>
	1456	/// Lower than or equal to comparison for complex numbers
	1457	/// </summary>
	1458	/// <param name="A">Left side</param>
	1459	/// <param name="B">Right side</param>
	1460	/// <returns>true if real part of A is lower then real part of B, false otherwise</returns>
	1461	/// <remarks>Only the real parts are compared!</remarks>
	1462	public static bool operator <=( Int32 A, complex B) {
	1463	return (A <= B.real);
	1464	}
	1465
	1466	/// <summary>
	1467	/// Add two complex values
	1468	/// </summary>
	1469	/// <param name="A">First summand</param>
	1470	/// <param name="B">Second summand</param>
	1471	/// <returns>Result</returns>
	1472	public static complex operator +( float A, complex B) {
	1473	complex ret;
	1474	ret.real = (double) (A + B.real);
	1475	ret.imag = (double) B.imag;
	1476	return ret;
	1477	}
	1478	/// <summary>
	1479	/// Subtract two values
	1480	/// </summary>
	1481	/// <param name="A">Minuend</param>
	1482	/// <param name="B">Subtrahend</param>
	1483	/// <returns>Result</returns>
	1484	public static complex operator -( float A, complex B) {
	1485	complex ret;
	1486	ret.real = (double) (A - B.real);
	1487	ret.imag = - (double) B.imag;
	1488	return ret;
	1489	}
	1490	/// <summary>
	1491	/// Multiply two values
	1492	/// </summary>
	1493	/// <param name="A">First factor</param>
	1494	/// <param name="B">Second factor</param>
	1495	/// <returns>Result</returns>
	1496	public static complex operator *( float A, complex B) {
	1497	complex ret;
	1498	ret.real = (double) (A * B.real);
	1499	ret.imag = (double) (A * B.imag);
	1500	return ret;
	1501	}
	1502	/// <summary>
	1503	/// Divide two values
	1504	/// </summary>
	1505	/// <param name="A">Divident</param>
	1506	/// <param name="B">Divisor</param>
	1507	/// <returns>Result</returns>
	1508	public static complex operator /( float A, complex B) {
	1509	complex ret;
	1510	if (A == 0) {
	1511	if (IsInfinity(B)) return NaN;
	1512	} else {
	1513	if (IsInfinity(B)) return ( complex )0;
	1514	}
	1515	if (B.real == 0 && B.imag == 0) {
	1516	return INF;
	1517	}
	1518	// this algorithm is taken from [1]. The one described in [2] was not taken. Tests
	1519	// did not show any advantage when using double precision floating point arithmetic.
	1520	double tmp;
	1521	if (Math.Abs(B.real) >= Math.Abs(B.imag)) {
	1522	tmp = (double) (B.imag * (1/B.real));
	1523	ret.imag = (double) (B.real + B.imag*tmp);
	1524	ret.real = (double) A/ret.imag;
	1525	ret.imag = - (double) (A*tmp)/ret.imag;
	1526	} else {
	1527	tmp = (double) (B.real * (1/B.imag));
	1528	ret.imag = (double) (B.imag + B.real*tmp);
	1529	ret.real = (double) (A*tmp)/ret.imag;
	1530	ret.imag = - (double) A/ret.imag;
	1531	}
	1532	return ret;
	1533	}
	1534	/// <summary>
	1535	/// Equality comparison for complex numbers
	1536	/// </summary>
	1537	/// <param name="A">Left side</param>
	1538	/// <param name="B">Right side</param>
	1539	/// <returns>Result</returns>
	1540	/// <remarks>Real inputs are converted to a complex number and the result is compared to the complex input.</remarks>
	1541	public static bool operator ==( float A, complex B) {
	1542	return (B.real == A && B.imag == 0.0);
	1543	}
	1544	/// <summary>
	1545	/// Unequality comparison for complex numbers
	1546	/// </summary>
	1547	/// <param name="A">Left side</param>
	1548	/// <param name="B">Right side</param>
	1549	/// <returns>true if real and imaginary parts of A and B are not equal, false otherwise</returns>
	1550	/// <remarks>Real inputs are converted to a complex number and the result is compared to the complex input.</remarks>
	1551	public static bool operator !=( float A, complex B) {
	1552	return (B.imag != 0.0) \|\| (B.real != A);
	1553	}
	1554	/// <summary>
	1555	/// Greater than comparison for complex numbers
	1556	/// </summary>
	1557	/// <param name="A">Left side</param>
	1558	/// <param name="B">Right side</param>
	1559	/// <returns>true if real part of A is greater than real part of B, false otherwise</returns>
	1560	/// <remarks>Only the real parts are compared!</remarks>
	1561	public static bool operator > ( float A, complex B) {
	1562	return (A > B.real);
	1563	}
	1564	/// <summary>
	1565	/// Lower than comparison for complex numbers
	1566	/// </summary>
	1567	/// <param name="A">Left side</param>
	1568	/// <param name="B">Right side</param>
	1569	/// <returns>true if real part of A is lower then real part of B, false otherwise</returns>
	1570	/// <remarks>Only the real parts are compared!</remarks>
	1571	public static bool operator < ( float A, complex B) {
	1572	return (A < B.real);
	1573	}
	1574	/// <summary>
	1575	/// Greater than or equal to comparison for complex numbers
	1576	/// </summary>
	1577	/// <param name="A">Left side</param>
	1578	/// <param name="B">Right side</param>
	1579	/// <returns>true if real part of A is greater than real part of B, false otherwise</returns>
	1580	/// <remarks>Only the real parts are compared!</remarks>
	1581	public static bool operator >=( float A, complex B) {
	1582	return (A >= B.real);
	1583	}
	1584	/// <summary>
	1585	/// Lower than or equal to comparison for complex numbers
	1586	/// </summary>
	1587	/// <param name="A">Left side</param>
	1588	/// <param name="B">Right side</param>
	1589	/// <returns>true if real part of A is lower then real part of B, false otherwise</returns>
	1590	/// <remarks>Only the real parts are compared!</remarks>
	1591	public static bool operator <=( float A, complex B) {
	1592	return (A <= B.real);
	1593	}
	1594
	1595	/// <summary>
	1596	/// Add two complex values
	1597	/// </summary>
	1598	/// <param name="A">First summand</param>
	1599	/// <param name="B">Second summand</param>
	1600	/// <returns>Result</returns>
	1601	public static complex operator +( byte A, complex B) {
	1602	complex ret;
	1603	ret.real = (double) (A + B.real);
	1604	ret.imag = (double) B.imag;
	1605	return ret;
	1606	}
	1607	/// <summary>
	1608	/// Subtract two values
	1609	/// </summary>
	1610	/// <param name="A">Minuend</param>
	1611	/// <param name="B">Subtrahend</param>
	1612	/// <returns>Result</returns>
	1613	public static complex operator -( byte A, complex B) {
	1614	complex ret;
	1615	ret.real = (double) (A - B.real);
	1616	ret.imag = - (double) B.imag;
	1617	return ret;
	1618	}
	1619	/// <summary>
	1620	/// Multiply two values
	1621	/// </summary>
	1622	/// <param name="A">First factor</param>
	1623	/// <param name="B">Second factor</param>
	1624	/// <returns>Result</returns>
	1625	public static complex operator *( byte A, complex B) {
	1626	complex ret;
	1627	ret.real = (double) (A * B.real);
	1628	ret.imag = (double) (A * B.imag);
	1629	return ret;
	1630	}
	1631	/// <summary>
	1632	/// Divide two values
	1633	/// </summary>
	1634	/// <param name="A">Divident</param>
	1635	/// <param name="B">Divisor</param>
	1636	/// <returns>Result</returns>
	1637	public static complex operator /( byte A, complex B) {
	1638	complex ret;
	1639	if (A == 0) {
	1640	if (IsInfinity(B)) return NaN;
	1641	} else {
	1642	if (IsInfinity(B)) return ( complex )0;
	1643	}
	1644	if (B.real == 0 && B.imag == 0) {
	1645	return INF;
	1646	}
	1647	// this algorithm is taken from [1]. The one described in [2] was not taken. Tests
	1648	// did not show any advantage when using double precision floating point arithmetic.
	1649	double tmp;
	1650	if (Math.Abs(B.real) >= Math.Abs(B.imag)) {
	1651	tmp = (double) (B.imag * (1/B.real));
	1652	ret.imag = (double) (B.real + B.imag*tmp);
	1653	ret.real = (double) A/ret.imag;
	1654	ret.imag = - (double) (A*tmp)/ret.imag;
	1655	} else {
	1656	tmp = (double) (B.real * (1/B.imag));
	1657	ret.imag = (double) (B.imag + B.real*tmp);
	1658	ret.real = (double) (A*tmp)/ret.imag;
	1659	ret.imag = - (double) A/ret.imag;
	1660	}
	1661	return ret;
	1662	}
	1663	/// <summary>
	1664	/// Equality comparison for complex numbers
	1665	/// </summary>
	1666	/// <param name="A">Left side</param>
	1667	/// <param name="B">Right side</param>
	1668	/// <returns>Result</returns>
	1669	/// <remarks>Real inputs are converted to a complex number and the result is compared to the complex input.</remarks>
	1670	public static bool operator ==( byte A, complex B) {
	1671	return (B.real == A && B.imag == 0.0);
	1672	}
	1673	/// <summary>
	1674	/// Unequality comparison for complex numbers
	1675	/// </summary>
	1676	/// <param name="A">Left side</param>
	1677	/// <param name="B">Right side</param>
	1678	/// <returns>true if real and imaginary parts of A and B are not equal, false otherwise</returns>
	1679	/// <remarks>Real inputs are converted to a complex number and the result is compared to the complex input.</remarks>
	1680	public static bool operator !=( byte A, complex B) {
	1681	return (B.imag != 0.0) \|\| (B.real != A);
	1682	}
	1683	/// <summary>
	1684	/// Greater than comparison for complex numbers
	1685	/// </summary>
	1686	/// <param name="A">Left side</param>
	1687	/// <param name="B">Right side</param>
	1688	/// <returns>true if real part of A is greater than real part of B, false otherwise</returns>
	1689	/// <remarks>Only the real parts are compared!</remarks>
	1690	public static bool operator > ( byte A, complex B) {
	1691	return (A > B.real);
	1692	}
	1693	/// <summary>
	1694	/// Lower than comparison for complex numbers
	1695	/// </summary>
	1696	/// <param name="A">Left side</param>
	1697	/// <param name="B">Right side</param>
	1698	/// <returns>true if real part of A is lower then real part of B, false otherwise</returns>
	1699	/// <remarks>Only the real parts are compared!</remarks>
	1700	public static bool operator < ( byte A, complex B) {
	1701	return (A < B.real);
	1702	}
	1703	/// <summary>
	1704	/// Greater than or equal to comparison for complex numbers
	1705	/// </summary>
	1706	/// <param name="A">Left side</param>
	1707	/// <param name="B">Right side</param>
	1708	/// <returns>true if real part of A is greater than real part of B, false otherwise</returns>
	1709	/// <remarks>Only the real parts are compared!</remarks>
	1710	public static bool operator >=( byte A, complex B) {
	1711	return (A >= B.real);
	1712	}
	1713	/// <summary>
	1714	/// Lower than or equal to comparison for complex numbers
	1715	/// </summary>
	1716	/// <param name="A">Left side</param>
	1717	/// <param name="B">Right side</param>
	1718	/// <returns>true if real part of A is lower then real part of B, false otherwise</returns>
	1719	/// <remarks>Only the real parts are compared!</remarks>
	1720	public static bool operator <=( byte A, complex B) {
	1721	return (A <= B.real);
	1722	}
	1723
	1724	#endregion HYCALPER AUTO GENERATED CODE
	1725
	1726	#region unary minus
	1727	/// <summary>
	1728	/// Unary minus operator
	1729	/// </summary>
	1730	/// <param name="A">Complex input</param>
	1731	/// <returns>Complex number similar to A, having real and imag part negated</returns>
	1732	public static complex operator -( complex A) {
	1733	complex ret = new complex();
	1734	ret.imag = -A.imag;
	1735	ret.real = -A.real;
	1736	return ret;
	1737	}
	1738	#endregion
	1739
	1740	#region CAST_OPERATORS
	1741	/// <summary>
	1742	/// Cast value to complex number
	1743	/// </summary>
	1744	/// <param name="a">Value to cast</param>
	1745	/// <returns>Complex number with the real part having the same value as a and the imaginary part is 0.</returns>
	1746	public static implicit operator complex(double a) {
	1747	return new complex(a, 0.0);
	1748	}
	1749	/// <summary>
	1750	/// Cast value to complex number
	1751	/// </summary>
	1752	/// <param name="a">Value to cast</param>
	1753	/// <returns>Complex number with the real part having the same value as the a and the imaginary part is 0.</returns>
	1754	public static implicit operator complex(float a) {
	1755	return new complex(a, 0.0);
	1756	}
	1757	/// <summary>
	1758	/// Cast value to complex number
	1759	/// </summary>
	1760	/// <param name="a">Value to cast</param>
	1761	/// <returns>Complex number being a copy of the real and imaginary parts of a.</returns>
	1762	public static implicit operator complex(fcomplex a) {
	1763	return new complex(a.real, a.imag);
	1764	}
	1765	/// <summary>
	1766	/// Cast value to complex number
	1767	/// </summary>
	1768	/// <param name="a">Value to cast</param>
	1769	/// <returns>Complex number with the real part having the same value as a and the imaginary part is 0.</returns>
	1770	public static implicit operator complex(byte a) {
	1771	return new complex(a, 0.0);
	1772	}
	1773	/// <summary>
	1774	/// Cast value to complex number
	1775	/// </summary>
	1776	/// <param name="a">Value to cast</param>
	1777	/// <returns>Complex number with the real part having the same value as a and the imaginary part is 0.</returns>
	1778	public static implicit operator complex(Int32 a) {
	1779	return new complex(a, 0.0);
	1780	}
	1781	/// <summary>
	1782	/// Cast value to complex number
	1783	/// </summary>
	1784	/// <param name="a">Value to cast</param>
	1785	/// <returns>Complex number with the real part having the same value as a and the imaginary part is 0.</returns>
	1786	public static implicit operator complex(Int64 a) {
	1787	return new complex(a, 0.0);
	1788	}
	1789
	1790	/// <summary>
	1791	/// Cast value from complex number
	1792	/// </summary>
	1793	/// <param name="a">Complex value to cast</param>
	1794	/// <returns>Double number with the real part of a </returns>
	1795	public static explicit operator double(complex a) {
	1796	return a.real;
	1797	}
	1798	/// <summary>
	1799	/// Cast value from complex number
	1800	/// </summary>
	1801	/// <param name="a">Complex value to cast</param>
	1802	/// <returns>number with the real part of a </returns>
	1803	/// <remarks>the return value is the result of a cast from double to float.</remarks>
	1804	public static explicit operator float(complex a) {
	1805	return (float)a.real;
	1806	}
	1807	/// <summary>
	1808	/// Cast value from complex number
	1809	/// </summary>
	1810	/// <param name="a">Complex value to cast</param>
	1811	/// <returns>float complex number with the real and imaginary parts being a copy of a </returns>
	1812	/// <remarks>The real and imaginary parts are the result of a cast to float.</remarks>
	1813	public static explicit operator fcomplex(complex a) {
	1814	return new fcomplex((float)a.real, (float)a.imag);
	1815	}
	1816	/// <summary>
	1817	/// Cast value from complex number
	1818	/// </summary>
	1819	/// <param name="a">Complex value to cast</param>
	1820	/// <returns>Number with the real part of a </returns>
	1821	/// <remarks>The return value is the result of a cast to byte.</remarks>
	1822	public static explicit operator byte(complex a) {
	1823	return (byte) a.real;
	1824	}
	1825	/// <summary>
	1826	/// Cast value from complex number
	1827	/// </summary>
	1828	/// <param name="a">Complex value to cast</param>
	1829	/// <returns>Number with the real part of a </returns>
	1830	/// <remarks>The return value is the result of a cast to Int32.</remarks>
	1831	public static explicit operator Int32(complex a) {
	1832	return (Int32) a.real;
	1833	}
	1834	/// <summary>
	1835	/// Cast value from complex number
	1836	/// </summary>
	1837	/// <param name="a">Complex value to cast</param>
	1838	/// <returns>number with the real part of a </returns>
	1839	/// <remarks>the return value is the result of a cast to Int64.</remarks>
	1840	public static explicit operator Int64(complex a) {
	1841	return (Int64) a.real;
	1842	}
	1843
	1844	public static implicit operator complex(System.Numerics.Complex a) {
	1845	return new complex(a.Real, a.Imaginary);
	1846	}
	1847	#endregion CAST_OPERATORS
	1848
	1849	#region Functions Basic Math
	1850	/// <summary>
	1851	/// Absolute value of input
	1852	/// </summary>
	1853	/// <param name="input">Input value</param>
	1854	/// <returns>The absolute value of the input</returns>
	1855	public static double Abs(complex input) {
	1856	return Math.Sqrt(input.real * input.real + input.imag * input.imag);
	1857	}
	1858	/// <summary>
	1859	/// Phase angle of complex number
	1860	/// </summary>
	1861	/// <param name="input">Input value</param>
	1862	/// <returns>The phase angle of the input</returns>
	1863	/// <remarks>For the result the Atan2 function of the <see cref="Math"/> class is used.</remarks>
	1864	public static double Angle(complex input) {
	1865	return Math.Atan2(input.imag, input.real);
	1866	}
	1867	/// <summary>
	1868	/// Arcus tangens of complex input
	1869	/// </summary>
	1870	/// <param name="input">Complex input</param>
	1871	/// <returns>Arcus tangens of complex input</returns>
	1872	/// <remarks></remarks>
	1873	public static complex Atan(complex input) {
	1874	complex ret = new complex(0, (float)0.5);
	1875	return (ret * Log((complex.i + input) / (complex.i - input)));
	1876	}
	1877	/// <summary>
	1878	/// Arcus cosinus of complex input
	1879	/// </summary>
	1880	/// <param name="input">Complex input</param>
	1881	/// <returns>Arcus cosinus of input</returns>
	1882	public static complex Acos(complex input) {
	1883	complex ni = complex.i * -1.0;
	1884	return complex.Log(complex.Sqrt(input * input - 1)
	1885	+ input) * ni;
	1886	}
	1887	/// <summary>
	1888	/// Arcus cosinus of input
	1889	/// </summary>
	1890	/// <param name="input">Input value</param>
	1891	/// <returns>Arcus cosinus of input</returns>
	1892	public static complex Acos(double input) {
	1893	if (Math.Abs(input) <= 1.0)
	1894	return new complex(Math.Acos(input), 0.0);
	1895	else {
	1896	return Acos((complex)input);
	1897	}
	1898	}
	1899	/// <summary>
	1900	/// Arcus sinus of complex input
	1901	/// </summary>
	1902	/// <param name="input">Input value</param>
	1903	/// <returns>Arcus sinus of input</returns>
	1904	public static complex Asin(double input) {
	1905	if (Math.Abs(input) <= 1.0)
	1906	return new complex(Math.Asin(input), 0.0);
	1907	else {
	1908	return Asin((complex)input);
	1909	}
	1910	}
	1911	/// <summary>
	1912	/// Arcus sinus of input
	1913	/// </summary>
	1914	/// <param name="input">Input value</param>
	1915	/// <returns>Arcus sinus of input</returns>
	1916	public static complex Asin(complex input) {
	1917	complex ret = Acos(input);
	1918	ret.real = Math.PI / 2 - ret.real;
	1919	return ret;
	1920	}
	1921	/// <summary>
	1922	/// Round towards positive infinity
	1923	/// </summary>
	1924	/// <param name="input">Input value</param>
	1925	/// <returns>Result is the next integer value greater then input</returns>
	1926	/// <remarks>ILMath.Ceiling operates in both: real and imaginary parts seperately</remarks>
	1927	public static complex Ceiling (complex input){
	1928	return new complex(
	1929	Math.Ceiling(input.real),
	1930	Math.Ceiling(input.imag)
	1931	);
	1932	}
	1933	/// <summary>
	1934	/// Round towards negative infinity
	1935	/// </summary>
	1936	/// <param name="input">Input value</param>
	1937	/// <returns>Result is the next integer value lower then input</returns>
	1938	/// <remarks>ILMath.Floor operates in both: real and imaginary parts seperately</remarks>
	1939	public static complex Floor (complex input){
	1940	return new complex(
	1941	Math.Floor(input.real),
	1942	Math.Floor(input.imag)
	1943	);
	1944	}
	1945	/// <summary>
	1946	/// Rounds towards nearest integer
	1947	/// </summary>
	1948	/// <param name="input">Input value</param>
	1949	/// <returns>Result is the nearest integer value for input</returns>
	1950	/// <remarks>ILMath.Round operates in both: real and imaginary parts deperately</remarks>
	1951	public static complex Round (complex input){
	1952	return new complex(
	1953	Math.Round(input.real),
	1954	Math.Round(input.imag)
	1955	);
	1956	}
	1957	/// <summary>
	1958	/// Signum function
	1959	/// </summary>
	1960	/// <param name="input">Complex input </param>
	1961	/// <returns>Sesult as input / Abs(input)</returns>
	1962	/// <remarks>Sign(input) with input being complex returns the projection onto
	1963	/// the unit circle. If input is 0+0i the result will be 0+0i.</remarks>
	1964	public static complex Sign (complex input){
	1965	if (input.real == 0.0 && input.imag == 0.0)
	1966	return new complex();
	1967	else {
	1968	double mag = Math.Sqrt(input.real * input.real + input.imag * input.imag);
	1969	return new complex(
	1970	input.real / mag,
	1971	input.imag / mag);
	1972	}
	1973	}
	1974	/// <summary>
	1975	/// Truncate a floating point complex value
	1976	/// </summary>
	1977	/// <param name="input">Input value</param>
	1978	/// <returns>Integer part of input</returns>
	1979	/// <remarks>Operates on real and imaginary parts seperately.</remarks>
	1980	public static complex Truncate (complex input){
	1981	return new complex(
	1982	Math.Truncate(input.real),
	1983	Math.Truncate(input.imag)
	1984	);
	1985	}
	1986	/// <summary>
	1987	/// Cosinus
	1988	/// </summary>
	1989	/// <param name="input">Input value</param>
	1990	/// <returns>Cosine of input</returns>
	1991	/// <remarks><para>The cosine is computed by the trigonometric euler equation: </para>
	1992	/// <para>0.5 * [exp(i input) + exp(-i input)]</para></remarks>
	1993	public static complex Cos(complex input) {
	1994	complex i = new complex(0, 1.0);
	1995	complex mi = new complex(0, -1.0);
	1996	return (Exp(i * input) + Exp(mi * input)) / 2.0;
	1997	}
	1998	/// <summary>
	1999	/// Cosinus hyperbolicus
	2000	/// </summary>
	2001	/// <param name="input">Input</param>
	2002	/// <returns>Cosine hyperbolicus of input</returns>
	2003	/// <remarks><para>The cosine is computed by the trigonometric euler equation: </para>
	2004	/// <para>(Exp(input) + Exp(-1.0 * input)) / 2.0</para></remarks>
	2005	public static complex Cosh(complex input) {
	2006	return (Exp(input) + Exp(-1.0 * input)) / 2.0;
	2007	}
	2008	/// <summary>
	2009	/// Sinus
	2010	/// </summary>
	2011	/// <param name="input">Input value</param>
	2012	/// <returns>Sinus of input</returns>
	2013	/// <remarks><para>The sinus is computed by the trigonometric euler equation: </para>
	2014	/// <para>(Exp(i * input) - Exp(-1.0 * i * input)) / (2.0 * i)</para></remarks>
	2015	public static complex Sin(complex input) {
	2016	complex i = new complex(0, 1.0);
	2017	complex mi = new complex(0, -1.0);
	2018	return (Exp(i * input) - Exp(mi * input)) / (2.0 * i);
	2019	}
	2020	/// <summary>
	2021	/// Sinus hyperbolicus
	2022	/// </summary>
	2023	/// <param name="input">Input</param>
	2024	/// <returns>Sinus hyperbolicus of input</returns>
	2025	/// <remarks><para>The sinus hyperbolicus is computed by the trigonometric euler equation: </para>
	2026	/// <para>(Exp(input) - Exp(-1.0 * input)) / 2.0</para></remarks>
	2027	public static complex Sinh(complex input) {
	2028	return (Exp(input) - Exp(-1.0 * input)) / 2.0;
	2029	}
	2030	/// <summary>
	2031	/// Complex exponent
	2032	/// </summary>
	2033	/// <param name="exponent">Exponent</param>
	2034	/// <returns>Result of exp(exponent)</returns>
	2035	/// <remarks>For complex exponents, exp(exponent) is computed by
	2036	/// <para>complex.FromPol(Math.Exp(exponent.real), exponent.imag)</para></remarks>
	2037	public static complex Exp(complex exponent) {
	2038	return complex.FromPol(Math.Exp(exponent.real), exponent.imag);
	2039	}
	2040	/// <summary>
	2041	/// Complex power for real exponent
	2042	/// </summary>
	2043	/// <param name="input">Basis</param>
	2044	/// <param name="exponent">Exponent</param>
	2045	/// <returns>Result of input power exponent</returns>
	2046	/// <remarks>The computation will be carried out by
	2047	/// <para>exp(log(input) * exponent)</para></remarks>
	2048	public static complex Pow(complex input, double exponent) {
	2049	complex ret = input.Log();
	2050	ret.imag *= exponent;
	2051	ret.real *= exponent;
	2052	return ret.Exp();
	2053	}
	2054	/// <summary>
	2055	/// Complex power - real basis, real exponent
	2056	/// </summary>
	2057	/// <param name="basis">Basis</param>
	2058	/// <param name="exponent">Exponent</param>
	2059	/// <returns>Complex number.</returns>
	2060	/// <remarks>The result will be a complex number. For negative basis
	2061	/// the basis will be converted to a complex number and the power
	2062	/// will be computed in the complex plane.</remarks>
	2063	public static complex Pow(double basis, double exponent) {
	2064	if (basis >= 0.0)
	2065	return Math.Pow(basis, exponent);
	2066	else
	2067	return Pow((complex)basis, exponent);
	2068	}
	2069	/// <summary>
	2070	/// Complex power - complex exponent
	2071	/// </summary>
	2072	/// <param name="basis">Basis</param>
	2073	/// <param name="exponent">Exponent</param>
	2074	/// <returns>Complex number exp(log(basis) * exponent).</returns>
	2075	/// <remarks>The result will be the complex number exp(log(basis) * exponent). </remarks>
	2076	public static complex Pow(complex basis, complex exponent) {
	2077	complex ret = (basis.Log() * exponent);
	2078	return ret.Exp();
	2079	}
	2080	/// <summary>
	2081	/// Square root
	2082	/// </summary>
	2083	/// <param name="input">Input value</param>
	2084	/// <returns>The square root of input</returns>
	2085	/// <remarks>If input is smaller than 0.0, the computation will be done in the complex plane. </remarks>
	2086	public static complex Sqrt(double input) {
	2087	if (input > 0.0)
	2088	return new complex(Math.Sqrt(input), 0.0);
	2089	else
	2090	return Sqrt(input);
	2091	}
	2092	/// <summary>
	2093	/// Square root
	2094	/// </summary>
	2095	/// <param name="input">Input value</param>
	2096	/// <returns>The square root of input</returns>
	2097	/// <remarks>Numerical recipes in C: Appendix C </remarks>
	2098	public static complex Sqrt(complex input) {
	2099	// Reference : numerical recipes in C: Appendix C
	2100	complex ret = new complex();
	2101	double x, y, w, r;
	2102	if (input.real == 0.0 && input.imag == 0.0)
	2103	return ret;
	2104	else {
	2105	x = (double)Math.Abs(input.real);
	2106	y = (double)Math.Abs(input.imag);
	2107	if (x >= y) {
	2108	r = y / x;
	2109	w = Math.Sqrt(x) * Math.Sqrt(0.5 * (1.0 + Math.Sqrt(1.0 + r * r)));
	2110	} else {
	2111	r = x / y;
	2112	w = Math.Sqrt(y) * Math.Sqrt(0.5 * (r + Math.Sqrt(1.0 + r * r)));
	2113	}
	2114	if (input.real >= 0.0) {
	2115	ret.real = w;
	2116	ret.imag = input.imag / (2.0 * w);
	2117	} else {
	2118	ret.imag = (input.imag >= 0) ? w : -w;
	2119	ret.real = input.imag / (2.0 * ret.imag);
	2120	}
	2121	return ret;
	2122	}
	2123	}
	2124	/// <summary>
	2125	/// Tangens
	2126	/// </summary>
	2127	/// <param name="input">Input value</param>
	2128	/// <returns>Tangens of input</returns>
	2129	/// <remarks>The tangens is
	2130	/// <para>sin(input) / cos(input)</para>
	2131	/// if cos(input) == 0.0+0.0i, INF will be returned.</remarks>
	2132	public static complex Tan(complex input) {
	2133	complex ci = Cos(input);
	2134	if (ci.real == 0.0 && ci.imag == 0.0)
	2135	return INF;
	2136	return (Sin(input) / ci);
	2137	}
	2138	/// <summary>
	2139	/// Tangens hyperbolicus
	2140	/// </summary>
	2141	/// <param name="input">Input value</param>
	2142	/// <returns>Tangens hyperbolicus</returns>
	2143	/// <remarks>The tangens hyperbolicus is
	2144	/// <para>sinh(input) / cosh(input)</para>
	2145	/// if cosh(input) == 0.0+0.0i, INF will be returned.</remarks>
	2146	public static complex Tanh(complex input) {
	2147	complex si = Cosh(input);
	2148	if (si.real == 0.0 && si.imag == 0.0)
	2149	return INF;
	2150	return (Sinh(input) / si);
	2151	}
	2152	/// <summary>
	2153	/// Complex logarithm
	2154	/// </summary>
	2155	/// <param name="input">Input value</param>
	2156	/// <returns>Complex logarithm of input</returns>
	2157	/// <remarks>The real part of the logarithm is computed by
	2158	/// <para>log (abs (input))</para>
	2159	/// <para>The imaginary part holds the phase of input.</para>
	2160	/// </remarks>
	2161	public static complex Log(complex input) {
	2162	complex ret = new complex();
	2163	ret.real = Math.Log(Math.Sqrt(input.real * input.real + input.imag * input.imag));
	2164	ret.imag = Math.Atan2(input.imag, input.real);
	2165	return ret;
	2166	}
	2167	/// <summary>
	2168	/// Logarithm of real input
	2169	/// </summary>
	2170	/// <param name="input">Input value - may be negative</param>
	2171	/// <returns>Complex logarithm</returns>
	2172	public static complex Log(double input) {
	2173	return Log (new complex(input,0.0));
	2174	}
	2175	/// <summary>
	2176	/// Logarithm of base 10 of real input
	2177	/// </summary>
	2178	/// <param name="input">Input value - may be negative</param>
	2179	/// <returns>Complex logarithm of base 10</returns>
	2180	public static complex Log10(double input) {
	2181	return Log(new complex(input,0.0)) * 0.43429448190325176;
	2182	}
	2183	/// <summary>
	2184	/// Logarithm of base 2 of real input
	2185	/// </summary>
	2186	/// <param name="input">Input value - may be negative</param>
	2187	/// <returns>Complex logarithm of base 2</returns>
	2188	public static complex Log2(double input) {
	2189	return Log(new complex(input,0.0)) * 1.4426950408889641;
	2190	}
	2191	/// <summary>
	2192	/// Logarithm of base 10
	2193	/// </summary>
	2194	/// <param name="input">Input value</param>
	2195	/// <returns>Logarithm of base 10</returns>
	2196	/// <seealso cref="ILNumerics.complex.Log(complex)"/>
	2197	public static complex Log10(complex input) {
	2198	return Log(input) * 0.43429448190325176;
	2199	}
	2200	/// <summary>
	2201	/// Logarithm of base 2
	2202	/// </summary>
	2203	/// <param name="input">Input value</param>
	2204	/// <returns>Logarithm of base 2.</returns>
	2205	/// <seealso cref="ILNumerics.complex.Log(complex)"/>
	2206	public static complex Log2(complex input) {
	2207	return Log(input) * 1.4426950408889634;
	2208	}
	2209	/// <summary>
	2210	/// Convert polar notation into cartesian notation
	2211	/// </summary>
	2212	/// <param name="magnitude">Magnitude</param>
	2213	/// <param name="angle">Phase</param>
	2214	/// <returns>Complex value having magnitude and phase</returns>
	2215	public static complex FromPol(double magnitude, double angle) {
	2216	return new complex(
	2217	magnitude * Math.Cos(angle),
	2218	magnitude * Math.Sin(angle)
	2219	);
	2220	}
	2221	/// <summary>
	2222	/// Convert to string
	2223	/// </summary>
	2224	/// <returns>String displaying the comlex number (full precision)</returns>
	2225	public override String ToString() {
	2226	if (imag>=0)
	2227	return String.Format("{0} + {1}i",real,imag);
	2228	else
	2229	return String.Format("{0} - {1}i",real,-imag);
	2230	}
	2231	private static string m_precSpecI = "";
	2232	private static string m_precSpecR = "";
	2233	private static int m_lastDigits = 0;
	2234	/// <summary>
	2235	/// Print formated output of this number, determine number of digits
	2236	/// </summary>
	2237	/// <param name="digits">Number of digits</param>
	2238	/// <returns>Formated output</returns>
	2239	public string ToString(int digits) {
	2240	if (digits < 1) return "";
	2241	if (digits != m_lastDigits) {
	2242	m_lastDigits = digits;
	2243	m_precSpecR = String.Format("{{0:f{0}}}",digits);
	2244	m_precSpecI = String.Format("{{1:f{0}}}i",digits);
	2245	}
	2246	if (imag >= 0) {
	2247	return String.Format(m_precSpecR+"+"+m_precSpecI,real,imag);
	2248	} else {
	2249	return String.Format(m_precSpecR+"-"+m_precSpecI,real,-imag);
	2250	}
	2251	}
	2252	/// <summary>
	2253	/// Magnitude of this complex instance
	2254	/// </summary>
	2255	/// <returns>Magnitude</returns>
	2256	public double Abs() {
	2257	return Math.Sqrt(real * real + imag * imag);
	2258	}
	2259	/// <summary>
	2260	/// Phase of this complex instance
	2261	/// </summary>
	2262	/// <returns>Phase</returns>
	2263	public double Angle() {
	2264	return Math.Atan2(imag, real);
	2265	}
	2266	/// <summary>
	2267	/// Arcus cosinus of this complex instance
	2268	/// </summary>
	2269	/// <returns>Arcus cosinus</returns>
	2270	public complex Acos() {
	2271	complex ret = new complex(0, -1);
	2272	return complex.Log(complex.Sqrt(this * this - 1)
	2273	+ this) * ret;
	2274	}
	2275	/// <summary>
	2276	/// Arcus sinus of this complex instance
	2277	/// </summary>
	2278	/// <returns>arcus sinus</returns>
	2279	public complex Asin() {
	2280	complex ret = Acos(this);
	2281	ret.real = Math.PI / 2 - ret.real;
	2282	return ret;
	2283	}
	2284	/// <summary>
	2285	/// Exponential / power of base e
	2286	/// </summary>
	2287	/// <returns>Power of base e</returns>
	2288	public complex Exp() {
	2289	return complex.FromPol(Math.Exp(real), imag);
	2290	}
	2291	/// <summary>
	2292	/// Complex power real exponent
	2293	/// </summary>
	2294	/// <param name="exponent">Exponent</param>
	2295	/// <returns>New complex number with result</returns>
	2296	/// <remarks>If this instance is a and the exponent is e than
	2297	/// the result will be the complex number exp(log(a) * e). </remarks>
	2298	public complex Pow(double exponent) {
	2299	complex ret = Log();
	2300	ret.imag *= exponent;
	2301	ret.real *= exponent;
	2302	return ret.Exp();
	2303	}
	2304	/// <summary>
	2305	/// Complex power - complex exponent
	2306	/// </summary>
	2307	/// <param name="exponent">Exponent</param>
	2308	/// <returns>Complex number exp(log(this) * exponent).</returns>
	2309	/// <remarks>If this instance is a than
	2310	/// the result will be the complex number exp(log(a) * exponent). </remarks>
	2311	public complex Pow(complex exponent) {
	2312	complex ret = (Log() * exponent);
	2313	return ret.Exp();
	2314	}
	2315	/// <summary>
	2316	/// Square root of this complex value
	2317	/// </summary>
	2318	/// <returns>Square root of this complex value</returns>
	2319	public complex Sqrt() {
	2320	// Reference : numerical recipes in C: Appendix C
	2321	complex ret = new complex();
	2322	double x, y, w, r;
	2323	if (real == 0.0 && imag == 0.0)
	2324	return ret;
	2325	else {
	2326	x = (double)Math.Abs(real);
	2327	y = (double)Math.Abs(imag);
	2328	if (x >= y) {
	2329	r = y / x;
	2330	w = Math.Sqrt(x) * Math.Sqrt(0.5 * (1.0 + Math.Sqrt(1.0 + r * r)));
	2331	} else {
	2332	r = x / y;
	2333	w = Math.Sqrt(y) * Math.Sqrt(0.5 * (r + Math.Sqrt(1.0 + r * r)));
	2334	}
	2335	if (real >= 0.0) {
	2336	ret.real = w;
	2337	ret.imag = imag / (2.0 * w);
	2338	} else {
	2339	ret.imag = (imag >= 0) ? w : -w;
	2340	ret.real = imag / ( 2.0 * ret.imag );
	2341	}
	2342	return ret;
	2343	}
	2344	}
	2345	/// <summary>
	2346	/// Logarithm of base e
	2347	/// </summary>
	2348	/// <returns>Logarithm of base e</returns>
	2349	/// <remarks>The logarithm of a complex number A is defined as follows: <br />
	2350	/// <list type="none"><item>real part: log(abs(A))</item>
	2351	/// <item>imag part: Atan2(imag(A),real(A))</item></list>
	2352	/// </remarks>
	2353	public complex Log() {
	2354	complex ret = new complex();
	2355	ret.real = Math.Log(Math.Sqrt(real * real + imag * imag));
	2356	ret.imag = Math.Atan2(imag, real);
	2357	return ret;
	2358	}
	2359	/// <summary>
	2360	/// Test if any of real or imaginary parts are NAN's
	2361	/// </summary>
	2362	/// <param name="input">Complex number to test</param>
	2363	/// <returns>true if any of real or imag part is not a number</returns>
	2364	public static bool IsNaN(complex input) {
	2365	if (double.IsNaN(input.real) \|\| double.IsNaN(input.imag))
	2366	return true;
	2367	else
	2368	return false;
	2369	}
	2370	/// <summary>
	2371	/// Test if any of real or imaginary parts are infinite
	2372	/// </summary>
	2373	/// <param name="input">Complex number to test</param>
	2374	/// <returns>true if any of real or imag part is infinite</returns>
	2375	public static bool IsInfinity(complex input) {
	2376	if (double.IsInfinity(input.real) \|\| double.IsInfinity(input.imag))
	2377	return true;
	2378	else
	2379	return false;
	2380	}
	2381	/// <summary>
	2382	/// Test if any of real or imaginary parts are pos.nfinite
	2383	/// </summary>
	2384	/// <param name="input">Complex number to test</param>
	2385	/// <returns>true if any of real or imag part is positive infinite</returns>
	2386	public static bool IsPositiveInfinity(complex input) {
	2387	if (double.IsPositiveInfinity(input.real) \|\| double.IsPositiveInfinity(input.imag))
	2388	return true;
	2389	else
	2390	return false;
	2391	}
	2392	/// <summary>
	2393	/// Test if any of real or imaginary parts are neg. infinite
	2394	/// </summary>
	2395	/// <param name="input">Complex number to test</param>
	2396	/// <returns>true if any of real or imag part is negative infinite</returns>
	2397	public static bool IsNegativeInfinity(complex input) {
	2398	if (double.IsNegativeInfinity(input.real) \|\| double.IsNegativeInfinity(input.imag))
	2399	return true;
	2400	else
	2401	return false;
	2402	}
	2403	/// <summary>
	2404	/// Test if any of real or imaginary parts are finite
	2405	/// </summary>
	2406	/// <param name="input">Complex number to test</param>
	2407	/// <returns>true if any of real and imag part is finite</returns>
	2408	public static bool IsFinite (complex input) {
	2409	if (ILMath.isfinite(input.real) && ILMath.isfinite(input.imag))
	2410	return true;
	2411	else
	2412	return false;
	2413	}
	2414	/// <summary>
	2415	/// Test if both of real or imaginary parts are 0
	2416	/// </summary>
	2417	/// <returns>true if real and imag part is 0</returns>
	2418	public bool iszero() {
	2419	if (real == 0.0 && imag == 0.0)
	2420	return true;
	2421	else
	2422	return false;
	2423	}
	2424	#endregion Functions Basic Math
	2425	}
	2426
	2427	}

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

Download in other formats:

Update cookies preferences