src/OpenFOAM/primitives/complex/complexI.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright held by original author
   6      \\/     M anipulation  |
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of OpenFOAM.
  10
  11     OpenFOAM is free software; you can redistribute it and/or modify it
  12     under the terms of the GNU General Public License as published by the
  13     Free Software Foundation; either version 2 of the License, or (at your
  14     option) any later version.
  15
  16     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
  17     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19     for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with OpenFOAM; if not, write to the Free Software Foundation,
  23     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  24
  25 \*---------------------------------------------------------------------------*/
  26
  27 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  28
  29 namespace Foam
  30 {
  31
  32 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  33
  34 inline complex::complex()
  35 {}
  36
  37
  38 inline complex::complex(const scalar Re, const scalar Im)
  39 :
  40     re(Re),
  41     im(Im)
  42 {}
  43
  44
  45 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
  46
  47 inline scalar complex::Re() const
  48 {
  49     return re;
  50 }
  51
  52
  53 inline scalar complex::Im() const
  54 {
  55     return im;
  56 }
  57
  58
  59 inline scalar& complex::Re()
  60 {
  61     return re;
  62 }
  63
  64
  65 inline scalar& complex::Im()
  66 {
  67     return im;
  68 }
  69
  70
  71 inline complex complex::conjugate() const
  72 {
  73     return complex(re, -im);
  74 }
  75
  76
  77 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
  78
  79 inline const complex& complex::operator=(const complex& c)
  80 {
  81     re = c.re;
  82     im = c.im;
  83     return *this;
  84 }
  85
  86
  87 inline void complex::operator+=(const complex& c)
  88 {
  89     re += c.re;
  90     im += c.im;
  91 }
  92
  93
  94 inline void complex::operator-=(const complex& c)
  95 {
  96     re -= c.re;
  97     im -= c.im;
  98 }
  99
 100
 101 inline void complex::operator*=(const complex& c)
 102 {
 103     *this = (*this)*c;
 104 }
 105
 106
 107 inline void complex::operator/=(const complex& c)
 108 {
 109     *this = *this/c;
 110 }
 111
 112
 113 inline const complex& complex::operator=(const scalar s)
 114 {
 115     re = s;
 116     im = 0.0;
 117     return *this;
 118 }
 119
 120
 121 inline void complex::operator+=(const scalar s)
 122 {
 123     re += s;
 124 }
 125
 126
 127 inline void complex::operator-=(const scalar s)
 128 {
 129     re -= s;
 130 }
 131
 132
 133 inline void complex::operator*=(const scalar s)
 134 {
 135     re *= s;
 136     im *= s;
 137 }
 138
 139
 140 inline void complex::operator/=(const scalar s)
 141 {
 142     re /= s;
 143     im /= s;
 144 }
 145
 146
 147 inline complex complex::operator!() const
 148 {
 149     return conjugate();
 150 }
 151
 152
 153 inline bool complex::operator==(const complex& c) const
 154 {
 155     return (equal(re, c.re) && equal(im, c.im));
 156 }
 157
 158
 159 inline bool complex::operator!=(const complex& c) const
 160 {
 161     return !operator==(c);
 162 }
 163
 164
 165 // * * * * * * * * * * * * * * * Friend Functions  * * * * * * * * * * * * * //
 166
 167
 168 inline scalar magSqr(const complex& c)
 169 {
 170     return (c.re*c.re + c.im*c.im);
 171 }
 172
 173
 174 inline complex sqr(const complex& c)
 175 {
 176     return c * c;
 177 }
 178
 179
 180 inline scalar mag(const complex& c)
 181 {
 182     return sqrt(magSqr(c));
 183 }
 184
 185
 186 inline const complex& max(const complex& c1, const complex& c2)
 187 {
 188     if (mag(c1) > mag(c2))
 189     {
 190         return c1;
 191     }
 192     else
 193     {
 194         return c2;
 195     }
 196 }
 197
 198
 199 inline const complex& min(const complex& c1, const complex& c2)
 200 {
 201     if (mag(c1) < mag(c2))
 202     {
 203         return c1;
 204     }
 205     else
 206     {
 207         return c2;
 208     }
 209 }
 210
 211
 212 inline complex limit(const complex& c1, const complex& c2)
 213 {
 214     return complex(limit(c1.re, c2.re), limit(c1.im, c2.im));
 215 }
 216
 217
 218 inline const complex& sum(const complex& c)
 219 {
 220     return c;
 221 }
 222
 223
 224 template<class Cmpt>
 225 class Tensor;
 226
 227 inline complex transform(const Tensor<scalar>&, const complex c)
 228 {
 229     return c;
 230 }
 231
 232
 233 // * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
 234
 235 inline complex operator+(const complex& c1, const complex& c2)
 236 {
 237     return complex
 238     (
 239         c1.re + c2.re,
 240         c1.im + c2.im
 241     );
 242 }
 243
 244
 245 inline complex operator-(const complex& c)
 246 {
 247     return complex
 248     (
 249         -c.re,
 250         -c.im
 251     );
 252 }
 253
 254
 255 inline complex operator-(const complex& c1, const complex& c2)
 256 {
 257     return complex
 258     (
 259         c1.re - c2.re,
 260         c1.im - c2.im
 261     );
 262 }
 263
 264
 265 inline complex operator*(const complex& c1, const complex& c2)
 266 {
 267     return complex
 268     (
 269         c1.re*c2.re - c1.im*c2.im,
 270         c1.im*c2.re + c1.re*c2.im
 271     );
 272 }
 273
 274
 275 inline complex operator/(const complex& c1, const complex& c2)
 276 {
 277     scalar sqrC2 = magSqr(c2);
 278
 279     return complex
 280     (
 281         (c1.re*c2.re + c1.im*c2.im)/sqrC2,
 282         (c1.im*c2.re - c1.re*c2.im)/sqrC2
 283     );
 284 }
 285
 286
 287 inline complex operator*(const scalar s, const complex& c)
 288 {
 289     return complex(s*c.re, s*c.im);
 290 }
 291
 292
 293 inline complex operator*(const complex& c, const scalar s)
 294 {
 295     return complex(s*c.re, s*c.im);
 296 }
 297
 298
 299 inline complex operator/(const complex& c, const scalar s)
 300 {
 301     return complex(c.re/s, c.im/s);
 302 }
 303
 304
 305 inline complex operator/(const scalar s, const complex& c)
 306 {
 307     scalar sqrC2 = magSqr(c);
 308
 309     // Bug fix, Hua Shan.  2/Apr/2010
 310     return complex
 311     (
 312         s*c.re/sqrC2,
 313        -s*c.im/sqrC2
 314     );
 315 }
 316
 317
 318 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 319
 320 } // End namespace Foam
 321
 322 // ************************************************************************* //