Context Navigation

source: branches/HeuristicLab.Problems.GaussianProcessTuning/ILNumerics.2.14.4735.573/Misc/ILFComplex.cs @ 9426

Visit:

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

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

Download in other formats:

Update cookies preferences