33 return l_complex(a.re + b.re, a.im + b.im);
38 return l_complex(a.re - b.re, a.im - b.im);
43 return l_complex(this->re + Re(op2), this->im + Im(op2));
53 return l_complex(this->re + op2, this->im);
64 return l_complex(this->re + op2, this->im);
75 return l_complex(this->re - op2, this->im);
86 return l_complex(this->re - Re(op2), this->im - Im(op2));
96 return l_complex(this->re - op2, this->im);
107 return l_complex(this->re * op2, this->im * op2);
118 return l_complex(this->re * op2, this->im * op2);
130 lc = lc + lc1;
return lc;
134 lc = lc - lc1;
return lc;
138 lc = lc + c;
return lc;
142 lc = lc - c;
return lc;
146 lc = lc + r;
return lc;
150 lc = lc - r;
return lc;
154 lc = lc + lr;
return lc;
158 lc = lc - lr;
return lc;
164 lc = lc * lc1;
return lc;
168 lc = lc * c;
return lc;
172 lc = lc * r;
return lc;
176 lc = lc * lr;
return lc;
223inline bool operator! (
const l_complex & a)
noexcept {
return !a.re && !a.im; }
225 {
return a.re==b.re && a.im==b.im; }
227 {
return a.re!=b.re || a.im!=b.im; }
229 {
return a.re==Re(b) && a.im==Im(b); }
231 {
return Re(a)==b.re && Im(a)==b.im; }
233 {
return a.re!=Re(b) || a.im!=Im(b); }
235 {
return Re(a)!=b.re || Im(a)!=b.im; }
237 {
return a.re==b && !a.im; }
239 {
return a==b.re && !b.im; }
241 {
return a.re!=b || !!a.im; }
243 {
return a!=b.re || !!b.im; }
245 {
return a.re==b && !a.im; }
247 {
return a==b.re && !b.im; }
249 {
return a.re!=b || !!a.im; }
251 {
return a!=b.re || !!b.im; }
253 {
return a.re==b && !a.im; }
255 {
return b.re==a && !b.im; }
257 {
return a.re!=b || !!a.im; }
259 {
return b.re!=a || !!b.im; }
262noexcept {
return(c.re==Re(_l_complex(a)) && c.im==Im(_l_complex(a))); }
264noexcept {
return(c.re!=Re(_l_complex(a)) || c.im!=Im(_l_complex(a))); }
266noexcept {
return(c.re==Re(_l_complex(a)) && c.im==Im(_l_complex(a))); }
268noexcept {
return(c.re!=Re(_l_complex(a)) || c.im!=Im(_l_complex(a))); }
The Data Type cdotprecision.
The Data Type dotprecision.
The Multiple-Precision Data Type l_complex.
friend l_complex operator*(const l_complex &a, const l_complex &b) noexcept
Implementation of standard algebraic multiplication operation.
friend l_complex operator-(const l_complex &)
Implementation of standard algebraic negative sign operation.
friend l_complex operator+(const l_complex &)
Implementation of standard algebraic positive sign operation.
The Multiple-Precision Data Type l_real.
The namespace cxsc, providing all functionality of the class library C-XSC.
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc) noexcept
Implementation of standard algebraic addition and allocation operation.
civector operator/(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of division operation.
cimatrix & operator*=(cimatrix &m, const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
cimatrix & operator/=(cimatrix &m, const cinterval &c) noexcept
Implementation of division and allocation operation.