xcomplex.h
Go to the documentation of this file.00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033 #ifndef PLANCK_XCOMPLEX_H
00034 #define PLANCK_XCOMPLEX_H
00035
00036 #include <iostream>
00037 #include <complex>
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056 template<typename T> class xcomplex
00057 {
00058 public:
00059 T re,
00060 im;
00061
00062
00063 xcomplex () {}
00064
00065 xcomplex (const T &re_, const T &im_)
00066 : re(re_), im(im_) {}
00067
00068 xcomplex (const T &re_)
00069 : re(re_), im(0) {}
00070
00071 xcomplex (const std::complex<T> &orig)
00072 : re(orig.real()), im(orig.imag()) {}
00073
00074 template<typename U> explicit xcomplex (const xcomplex<U> &orig)
00075 : re(T(orig.re)), im(T(orig.im)) {}
00076
00077
00078 operator std::complex<T> () const
00079 { return std::complex<T>(re,im); }
00080
00081
00082 T &real() { return re; }
00083
00084 const T &real() const { return re; }
00085
00086 T &imag() { return im; }
00087
00088 const T &imag() const { return im; }
00089
00090
00091 void Set (const T &re_, const T &im_)
00092 { re = re_; im = im_; }
00093
00094
00095 xcomplex &operator= (const xcomplex &orig)
00096 { re=orig.re; im=orig.im; return *this; }
00097
00098 xcomplex &operator= (const std::complex<T> &orig)
00099 { re=orig.real(); im=orig.imag(); return *this; }
00100
00101 xcomplex &operator= (const T &orig)
00102 { re=orig; im=0; return *this; }
00103
00104 xcomplex &operator+= (const xcomplex &b)
00105 { re+=b.re; im+=b.im; return *this; }
00106
00107 xcomplex &operator-= (const xcomplex &b)
00108 { re-=b.re; im-=b.im; return *this; }
00109
00110 xcomplex &operator*= (const xcomplex &b)
00111 {
00112 T tr=re*b.re-im*b.im, ti=re*b.im+im*b.re;
00113 re=tr; im=ti;
00114 return *this;
00115 }
00116
00117 xcomplex &operator/= (const xcomplex &b)
00118 {
00119 std::complex<T> tmp=*this;
00120 tmp /= std::complex<T>(b);
00121 *this=tmp;
00122 return *this;
00123 }
00124
00125 xcomplex &operator*= (const T &fact)
00126 { re*=fact; im*=fact; return *this; }
00127
00128 xcomplex &operator/= (const T &div)
00129 { re/=div; im/=div; return *this; }
00130
00131 xcomplex operator* (const T &fact) const
00132 { return xcomplex (re*fact,im*fact); }
00133
00134 xcomplex operator* (const xcomplex &b) const
00135 { return xcomplex (re*b.re-im*b.im, re*b.im+im*b.re); }
00136
00137 xcomplex operator/ (const xcomplex &b) const
00138 { return xcomplex(std::complex<T>(*this)/std::complex<T>(b)); }
00139
00140 xcomplex operator/ (const T &div) const
00141 { return xcomplex (re/div,im/div); }
00142
00143 xcomplex operator+ (const xcomplex &b) const
00144 { return xcomplex (re+b.re, im+b.im); }
00145
00146 xcomplex operator- (const xcomplex &b) const
00147 { return xcomplex (re-b.re, im-b.im); }
00148
00149 xcomplex operator- () const
00150 { return xcomplex (-re,-im); }
00151
00152
00153 void Negate()
00154 { re=-re; im=-im; }
00155
00156 void Conjugate()
00157 { im=-im; }
00158
00159 void Rotate(T angle)
00160 {
00161 T ca=cos(angle), sa=sin(angle);
00162 T tmp=re;
00163 re=tmp*ca-im*sa; im=tmp*sa+im*ca;
00164 }
00165
00166 xcomplex conj() const
00167 { return xcomplex (re,-im); }
00168
00169
00170 xcomplex times_i() const
00171 { return xcomplex (-im,re); }
00172
00173
00174 T norm() const
00175 { return re*re + im*im; }
00176 };
00177
00178
00179
00180 template <typename T> inline xcomplex<T> conj (const xcomplex<T> &num)
00181 { return xcomplex<T> (num.re, -num.im); }
00182
00183
00184 template <typename T> inline T norm (const xcomplex<T> &num)
00185 { return num.re*num.re + num.im*num.im; }
00186
00187
00188 template <typename T> inline T abs (const xcomplex<T> &num)
00189 {
00190 using namespace std;
00191 return abs(complex<T>(num));
00192 }
00193
00194
00195 template <typename T> inline xcomplex<T> exp (const xcomplex<T> &num)
00196 {
00197 using namespace std;
00198 return xcomplex<T>(exp(complex<T>(num)));
00199 }
00200
00201
00202 template <typename T> inline xcomplex<T> operator*
00203 (const T &f1, const xcomplex<T> &f2)
00204 { return xcomplex<T> (f1*f2.re, f1*f2.im); }
00205
00206
00207 template <typename T> inline xcomplex<T> operator/
00208 (const T &f1, const xcomplex<T> &f2)
00209 { return xcomplex<T>(f1)/f2; }
00210
00211
00212 template<typename T>
00213 inline std::ostream &operator<< (std::ostream &os, const xcomplex<T> &val)
00214 { os << "(" << val.re << "," << val.im << ")"; return os; }
00215
00216 typedef xcomplex<double> dcomplex;
00217 typedef xcomplex<float> fcomplex;
00218
00219
00220
00221 #endif