casacore
Complex.h
Go to the documentation of this file.
1//# Complex.h: Single and double precision complex numbers
2//# Copyright (C) 2000,2001,2002,2004
3//# Associated Universities, Inc. Washington DC, USA.
4//#
5//# This library is free software; you can redistribute it and/or modify it
6//# under the terms of the GNU Library General Public License as published by
7//# the Free Software Foundation; either version 2 of the License, or (at your
8//# option) any later version.
9//#
10//# This library is distributed in the hope that it will be useful, but WITHOUT
11//# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12//# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public
13//# License for more details.
14//#
15//# You should have received a copy of the GNU Library General Public License
16//# along with this library; if not, write to the Free Software Foundation,
17//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
18//#
19//# Correspondence concerning AIPS++ should be addressed as follows:
20//# Internet email: aips2-request@nrao.edu.
21//# Postal address: AIPS++ Project Office
22//# National Radio Astronomy Observatory
23//# 520 Edgemont Road
24//# Charlottesville, VA 22903-2475 USA
25//#
26//# $Id$
27
28
29#ifndef CASA_COMPLEX_H
30#define CASA_COMPLEX_H
31
32
33//# Includes
34#include <casacore/casa/aips.h>
35#include <casacore/casa/BasicSL/Complexfwd.h>
36#include <casacore/casa/complex.h>
37
38namespace casacore { //# NAMESPACE CASACORE - BEGIN
39
40// <summary>
41// Single and double precision complex numbers
42// </summary>
43// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="" demos="">
44// </reviewed>
45
46// <synopsis>
47// The class <src>Complex</src> is a straight typedef as the
48// standard library <src>complex<float></src>.
49//
50// In a similar way <src>DComplex</src> is typedef-ed as
51// <src>complex<double></src>.
52//
53// <linkto class=IComplex>IComplex</linkto> is defined as a specific class.
54// It is only used by the <src>FITS</src> classes.
55//
56// <src>lDComplex</src> has not been defined: <src>long double</src> is not
57// part of the standard Casacore data suite (yet)
58//
59// A set of global functions are added for historic reasons (they were present
60// in the original Casacore/gcc complex implementation).
61//
62// See the standard library documentation for the expected behaviour of
63// the <src>Complex</src> and <src>DComplex</src> classes.
64//
65// <note role=tip> In the following all references to <src>Complex</src>
66// can be replaced with <src>DComplex</src>. with simultaneous
67// replacement of <src>Float</src> with <src>Double</src>. </note>
68//
69// Complex numbers may be constructed and used in the following ways:
70// <dl>
71// <dt>Complex x;</dt>
72// <dd> Declares an uninitialized Complex. </dd>
73//
74// <dt>Complex x = 2; Complex y(2.0);</dt>
75// <dd> Set x and y to the Complex value (2.0, 0.0); </dd>
76//
77// <dt>Complex x(2, 3);</dt>
78// <dd> Sets x to the Complex value (2, 3); </dd>
79//
80// <dt>Complex u(x); Complex v = x;</dt>
81// <dd> Set u and v to the same value as x. </dd>
82//
83// <dt>Float real(Complex& x);</dt>
84// <dd> returns the real part of x. </dd>
85//
86// <dt>Float imag(Complex& x);</dt>
87// <dd> returns the imaginary part of x. </dd>
88//
89// <dt>Float abs(Complex& x);</dt>
90// <dd> returns the magnitude of x. </dd>
91//
92// <dt>Float norm(Complex& x);</dt>
93// <dd> returns the square of the magnitude of x. </dd>
94//
95// <dt>Float arg(Complex& x);</dt>
96// <dd> returns the argument (amplitude) of x. </dd>
97//
98// <dt>Complex polar(Float r, Float t = 0.0);</dt>
99// <dd> returns a Complex with abs of r and arg of t. </dd>
100//
101// <dt>Complex conj(Complex& x);</dt>
102// <dd> returns the complex conjugate of x </dd>
103//
104// <dt>Complex cos(Complex& x);</dt>
105// <dd> returns the complex cosine of x. </dd>
106//
107// <dt>Complex sin(Complex& x);</dt>
108// <dd> returns the complex sine of x. </dd>
109//
110// <dt>Complex cosh(Complex& x);</dt>
111// <dd> returns the complex hyperbolic cosine of x. </dd>
112//
113// <dt>Complex sinh(Complex& x);</dt>
114// <dd> returns the complex hyperbolic sine of x. </dd>
115//
116// <dt>Complex exp(Complex& x);</dt>
117// <dd> returns the exponential of x. </dd>
118//
119// <dt>Complex log(Complex& x);</dt>
120// <dd> returns the natural log of x. </dd>
121//
122// <dt>Complex pow(Complex& x, long p);</dt>
123// <dd> returns x raised to the p power. </dd>
124//
125// <dt>Complex pow(Complex& x, Complex& p);</dt>
126// <dd> returns x raised to the p power. </dd>
127//
128// <dt>Complex sqrt(Complex& x);</dt>
129// <dd> returns the square root of x. </dd>
130//
131// <dt> Complex min(Complex x,Complex y);
132// <dd> Returns the minumum of x,y (using operator<=, i.e. the norm).
133//
134// <dt> Complex max(Complex x,Complex y);
135// <dd> Returns the maximum of x,y (using operator>=, i.e. the norm).
136//
137// <dt>Bool near(Complex val1, Complex val2, Double tol = 1.0e-5);</dt>
138// <dd> returns whether val1 is relatively near val2 (see Math.h).
139// (Note the Double tolerance) </dd>
140//
141// <dt>Bool nearAbs(Complex val1, Complex val2, Double tol = 1.0e-5);</dt>
142// <dd> returns whether val1 is absolutely near val2 (see Math.h).
143// (Note the Double tolerance) </dd>
144//
145// <dt>ostream << x;</dt>
146// <dd> prints x in the form (re, im). </dd>
147//
148// <dt>istream >> x;</dt>
149// <dd> reads x in the form (re, im), or just (re) or re in which case the
150// imaginary part is set to zero. </dd>
151// </dl>
152// </synopsis>
153
154//# <todo asof="2000/11/27">
155//# </todo>
156
157// <group name="Complex_desc">
159// <summary>Complex NaN and Infinity</summary>
160// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="" demos="">
161// </reviewed>
162// <group name="Complex NaN and Infinity">
163Bool isNaN (const Complex& val);
164void setNaN(Complex& val);
165Bool isInf (const Complex& val);
166void setInf(Complex& val);
168// </group>
169
170// <summary>Complex comparisons </summary>
171// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="" demos="">
172// </reviewed>
173// <group name="Complex comparisons">
174//# On Linux comparing the norm does not work well in debug mode
175//# for equal values. Therefore they are compared for equality first.
176inline Bool operator>= (const Complex& left, const Complex& right)
177 { return left==right ? True : norm(left) >= norm(right); }
178inline Bool operator> (const Complex& left, const Complex& right)
179 { return left==right ? False : norm(left) > norm(right); }
180inline Bool operator<= (const Complex& left, const Complex& right)
181 { return left==right ? True : norm(left) <= norm(right); }
182inline Bool operator< (const Complex& left, const Complex& right)
183 { return left==right ? False : norm(left) < norm(right); }
184// </group>
185
186
187// <summary>DComplex NaN and Infinity</summary>
188// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="" demos="">
189// </reviewed>
190// <group name="DComplex NaN and Infinity">
191Bool isNaN (const DComplex& val);
192void setNaN(DComplex& val);
193Bool isInf (const DComplex& val);
194void setInf(DComplex& val);
196// </group>
197
198// <summary> DComplex comparisons </summary>
199// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="" demos="">
200// </reviewed>
201// <group name="DComplex comparisons">
202inline Bool operator>= (const DComplex& left, const DComplex& right)
203 { return norm(left) >= norm(right); }
204inline Bool operator> (const DComplex& left, const DComplex& right)
205 { return norm(left) > norm(right); }
206inline Bool operator<= (const DComplex& left, const DComplex& right)
207 { return norm(left) <= norm(right); }
208inline Bool operator< (const DComplex& left, const DComplex& right)
209 { return norm(left) < norm(right); }
210// </group>
211
212
213//# Global functions
214// <summary> Additional complex mathematical functions </summary>
215// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="" demos="">
216// </reviewed>
217// <group name=math>
218inline Double fabs(const DComplex &val) { return std::abs(val); }
219inline Float fabs(const Complex &val) { return std::abs(val); }
221inline DComplex square(const DComplex &val) { return val*val; }
222inline Complex square(const Complex &val) { return val*val; }
223
224inline DComplex cube(const DComplex &val) { return val*val*val; }
225inline Complex cube(const Complex &val) { return val*val*val; }
226
227// ArrayMath::pow needs this pow function.
229
230// We have to explicitly implement these for different type operands
231inline DComplex operator+(const DComplex& d, const Complex& c) {
232 return (DComplex)c + d;
233}
234
235inline DComplex operator+(const Complex& c, const DComplex& d) {
236 return (DComplex)c + d;
237}
238
239inline DComplex operator-(const DComplex& d, const Complex& c) {
240 return d - (DComplex)c;
241}
242
243inline DComplex operator-(const Complex& c, const DComplex& d) {
244 return (DComplex)c - d;
245}
246
247// QMath and scimath need these operators * and /
248// <group>
249inline Complex operator*(const Complex& val, Double f) { return val*Float(f); }
250inline Complex operator*(Double f, const Complex& val) { return val*Float(f); }
251inline Complex operator/(const Complex& val, Double f) { return val/Float(f); }
252inline Complex operator/(Double f, const Complex& val) { return Float(f)/val; }
253// </group>
254// These operators are useful, otherwise both Float and Double are applicable
255// for Ints.
256// <group>
257inline Complex operator*(const Complex& val, Int f) { return val*Float(f); }
258inline Complex operator*(Int f, const Complex& val) { return val*Float(f); }
259inline Complex operator/(const Complex& val, Int f) { return val/Float(f); }
260inline Complex operator/(Int f, const Complex& val) { return Float(f)/val; }
261// </group>
262// </group>
263
264// <summary> The near functions </summary>
265// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="" demos="">
266// </reviewed>
267// <group name=near>
268Bool near(const Complex &val1, const Complex &val2, Double tol=1.0e-5);
269Bool near(const DComplex &val1, const DComplex &val2, Double tol=1.0e-13);
270Bool nearAbs(const Complex &val1, const Complex &val2, Double tol=1.0e-5);
271Bool nearAbs(const DComplex &val1, const DComplex &val2, Double tol=1.0e-13);
272inline Bool allNear(const Complex &val1, const Complex &val2,
273 Double tol=1.0e-5)
274 { return near(val1, val2, tol); }
275inline Bool allNear(const DComplex &val1, const DComplex &val2,
276 Double tol=1.0e-13)
277 { return near(val1, val2, tol); }
278inline Bool allNearAbs(const Complex &val1, const Complex &val2,
279 Double tol=1.0e-5)
280 { return nearAbs(val1, val2, tol); }
281inline Bool allNearAbs(const DComplex &val1, const DComplex &val2,
282 Double tol=1.0e-13)
283 { return nearAbs(val1, val2, tol); }
284// </group>
285
286// <summary> Max and min, floor and ceil functions </summary>
287// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="" demos="">
288// </reviewed>
289// <group name=maxmin>
290inline Complex max(const Complex &x, const Complex &y)
291 { return x >= y ? x : y; }
292inline DComplex max(const DComplex &x, const DComplex &y)
293 { return x >= y ? x : y; }
294
295inline Complex min(const Complex &x, const Complex &y)
296 { return x <= y ? x : y; }
297inline DComplex min(const DComplex &x, const DComplex &y)
298 { return x <= y ? x : y; }
299
300inline Complex floor(const Complex &x) {
301 return Complex(std::floor(x.real()), std::floor(x.imag())); }
302inline DComplex floor(const DComplex &x) {
303 return DComplex(std::floor(x.real()), std::floor(x.imag())); }
304
305inline Complex ceil(const Complex &x) {
306 return Complex(std::ceil(x.real()), std::ceil(x.imag())); }
307inline DComplex ceil(const DComplex &x) {
308 return DComplex(std::ceil(x.real()), std::ceil(x.imag())); }
309// </group>
310
311// <summary> fmod </summary>
312// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="" demos="">
313// </reviewed>
314// <group name=fmod>
315DComplex fmod(const DComplex &in, const DComplex &f);
316Complex fmod(const Complex &in, const Complex &f);
317// </group>
318
319// <summary> Inverse trigonometry </summary>
320// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="" demos="">
321// </reviewed>
322// <group name=inverse>
323// atan not valid for z == -1
324DComplex atan(const DComplex &in);
330DComplex atan2(const DComplex &in, const DComplex &t2);
331Complex atan2(const Complex &in, const Complex &t2);
332// </group>
333
334// <summary> Error function </summary>
335// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="" demos="">
336// </reviewed>
337// <group name=erf>
338// Preliminary to get Functionals working. erf(z) will return erf(real(z))
339// only for now.
340DComplex erf(const DComplex &in);
341Complex erf(const Complex &in);
342DComplex erfc(const DComplex &in);
344// </group>
345
346// </group>
347
348} //# NAMESPACE CASACORE - END
349
350// Define real & complex conjugation for non-complex types
351// and put comparisons into std namespace.
352namespace std {
353 inline float conj(float x) { return x; }
354 inline double conj(double x) { return x; }
355 using casacore::operator>;
356 using casacore::operator>=;
357 using casacore::operator<;
358 using casacore::operator<=;
359}
360
361#endif
DComplex fmod(const DComplex &in, const DComplex &f)
fmod
Complex max(const Complex &x, const Complex &y)
Max and min, floor and ceil functions.
Definition: Complex.h:291
Bool operator>=(const Complex &left, const Complex &right)
Complex comparisons.
Definition: Complex.h:176
Double fabs(const DComplex &val)
Additional complex mathematical functions.
Definition: Complex.h:219
Bool isNaN(const DComplex &val)
DComplex NaN and Infinity.
Bool isNaN(const Complex &val)
Complex NaN and Infinity.
DComplex erf(const DComplex &in)
Error function.
DComplex atan(const DComplex &in)
Inverse trigonometry.
Bool near(const Complex &val1, const Complex &val2, Double tol=1.0e-5)
The near functions.
const Double c
Fundamental physical constants (SI units):
this file contains all the compiler specific defines
Definition: mainpage.dox:28
const Bool False
Definition: aipstype.h:44
LatticeExprNode isNaN(const LatticeExprNode &expr)
Test if a value is a NaN.
LatticeExprNode asin(const LatticeExprNode &expr)
LatticeExprNode fmod(const LatticeExprNode &left, const LatticeExprNode &right)
LatticeExprNode operator>(const LatticeExprNode &left, const LatticeExprNode &right)
LatticeExprNode acos(const LatticeExprNode &expr)
LatticeExprNode max(const LatticeExprNode &left, const LatticeExprNode &right)
TableExprNode isFinite(const TableExprNode &node)
Function to test if a scalar or array is finite.
Definition: ExprNode.h:1630
LatticeExprNode atan(const LatticeExprNode &expr)
bool allNearAbs(const C1 &l, const C2 &r, U tolerance)
Test if all elements of the containers are absolutely near each other.
Definition: StdLogical.h:54
TableExprNode nearAbs(const TableExprNode &left, const TableExprNode &right)
Definition: ExprNode.h:1250
TableExprNode isInf(const TableExprNode &node)
Definition: ExprNode.h:1626
LatticeExprNode abs(const LatticeExprNode &expr)
Numerical 1-argument functions which result in a real number regardless of input expression type.
T norm(const TableVector< T > &tv)
Definition: TabVecMath.h:414
LatticeExprNode atan2(const LatticeExprNode &left, const LatticeExprNode &right)
Numerical 2-argument functions.
float Float
Definition: aipstype.h:54
LatticeExprNode operator<(const LatticeExprNode &left, const LatticeExprNode &right)
LatticeExprNode operator>=(const LatticeExprNode &left, const LatticeExprNode &right)
int Int
Definition: aipstype.h:50
bool Bool
Define the standard types used by Casacore.
Definition: aipstype.h:42
bool allNear(const C1 &l, const C2 &r, U tolerance)
Test if all elements of the containers are relatively near each other.
Definition: StdLogical.h:49
LatticeExprNode floor(const LatticeExprNode &expr)
const Bool True
Definition: aipstype.h:43
double Double
Definition: aipstype.h:55
Bool near(const GaussianBeam &left, const GaussianBeam &other, const Double relWidthTol, const Quantity &absPaTol)
LatticeExprNode operator<=(const LatticeExprNode &left, const LatticeExprNode &right)
LatticeExprNode ceil(const LatticeExprNode &expr)
Define real & complex conjugation for non-complex types and put comparisons into std namespace.
Definition: Complex.h:352
float conj(float x)
Definition: Complex.h:353
Bool operator<(const Complex &left, const Complex &right)
Definition: Complex.h:182
Complex cube(const Complex &val)
Definition: Complex.h:225
Complex operator*(const Complex &val, Double f)
QMath and scimath need these operators * and /.
Definition: Complex.h:249
DComplex operator+(const Complex &c, const DComplex &d)
Definition: Complex.h:235
DComplex atan2(const DComplex &in, const DComplex &t2)
DComplex operator+(const DComplex &d, const Complex &c)
ArrayMath::pow needs this pow function.
Definition: Complex.h:231
DComplex min(const DComplex &x, const DComplex &y)
Definition: Complex.h:297
Complex operator/(Int f, const Complex &val)
Definition: Complex.h:260
DComplex cube(const DComplex &val)
Definition: Complex.h:224
Complex operator*(const Complex &val, Int f)
These operators are useful, otherwise both Float and Double are applicable for Ints.
Definition: Complex.h:257
Complex min(const Complex &x, const Complex &y)
Definition: Complex.h:295
Bool allNear(const Complex &val1, const Complex &val2, Double tol=1.0e-5)
Definition: Complex.h:273
Bool nearAbs(const DComplex &val1, const DComplex &val2, Double tol=1.0e-13)
Complex operator/(const Complex &val, Double f)
Definition: Complex.h:251
DComplex ceil(const DComplex &x)
Definition: Complex.h:307
DComplex floor(const DComplex &x)
Definition: Complex.h:302
Complex fmod(const Complex &in, const Complex &f)
Complex atan2(const Complex &in, const Complex &t2)
DComplex operator-(const DComplex &d, const Complex &c)
Definition: Complex.h:239
Bool allNearAbs(const DComplex &val1, const DComplex &val2, Double tol=1.0e-13)
Definition: Complex.h:282
Bool nearAbs(const Complex &val1, const Complex &val2, Double tol=1.0e-5)
Bool allNear(const DComplex &val1, const DComplex &val2, Double tol=1.0e-13)
Definition: Complex.h:276
Bool operator>(const Complex &left, const Complex &right)
Definition: Complex.h:178
DComplex operator-(const Complex &c, const DComplex &d)
Definition: Complex.h:243
Complex operator*(Int f, const Complex &val)
Definition: Complex.h:258
Complex operator/(Double f, const Complex &val)
Definition: Complex.h:252
DComplex square(const DComplex &val)
Definition: Complex.h:221
DComplex max(const DComplex &x, const DComplex &y)
Definition: Complex.h:293
Bool operator<=(const Complex &left, const Complex &right)
Definition: Complex.h:180
Bool allNearAbs(const Complex &val1, const Complex &val2, Double tol=1.0e-5)
Definition: Complex.h:279
Complex operator/(const Complex &val, Int f)
Definition: Complex.h:259
Bool near(const DComplex &val1, const DComplex &val2, Double tol=1.0e-13)
Complex operator*(Double f, const Complex &val)
Definition: Complex.h:250
Complex square(const Complex &val)
Definition: Complex.h:222