src/OpenFOAM/primitives/complex/complexI.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
   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 void complex::operator=(const complex& c)
  80 {
  81     re = c.re;
  82     im = c.im;
  83 }
  84
  85
  86 inline void complex::operator+=(const complex& c)
  87 {
  88     re += c.re;
  89     im += c.im;
  90 }
  91
  92
  93 inline void complex::operator-=(const complex& c)
  94 {
  95     re -= c.re;
  96     im -= c.im;
  97 }
  98
  99
 100 inline void complex::operator*=(const complex& c)
 101 {
 102     *this = (*this)*c;
 103 }
 104
 105
 106 inline void complex::operator/=(const complex& c)
 107 {
 108     *this = *this/c;
 109 }
 110
 111
 112 inline void complex::operator=(const scalar s)
 113 {
 114     re = s;
 115     im = 0.0;
 116 }
 117
 118
 119 inline void complex::operator+=(const scalar s)
 120 {
 121     re += s;
 122 }
 123
 124
 125 inline void complex::operator-=(const scalar s)
 126 {
 127     re -= s;
 128 }
 129
 130
 131 inline void complex::operator*=(const scalar s)
 132 {
 133     re *= s;
 134     im *= s;
 135 }
 136
 137
 138 inline void complex::operator/=(const scalar s)
 139 {
 140     re /= s;
 141     im /= s;
 142 }
 143
 144
 145 inline complex complex::operator!() const
 146 {
 147     return conjugate();
 148 }
 149
 150
 151 inline bool complex::operator==(const complex& c) const
 152 {
 153     return (equal(re, c.re) && equal(im, c.im));
 154 }
 155
 156
 157 inline bool complex::operator!=(const complex& c) const
 158 {
 159     return !operator==(c);
 160 }
 161
 162
 163 // * * * * * * * * * * * * * * * Friend Functions  * * * * * * * * * * * * * //
 164
 165
 166 inline scalar magSqr(const complex& c)
 167 {
 168     return (c.re*c.re + c.im*c.im);
 169 }
 170
 171
 172 inline complex sqr(const complex& c)
 173 {
 174     return c * c;
 175 }
 176
 177
 178 inline scalar mag(const complex& c)
 179 {
 180     return sqrt(magSqr(c));
 181 }
 182
 183
 184 inline const complex& max(const complex& c1, const complex& c2)
 185 {
 186     if (mag(c1) > mag(c2))
 187     {
 188         return c1;
 189     }
 190     else
 191     {
 192         return c2;
 193     }
 194 }
 195
 196
 197 inline const complex& min(const complex& c1, const complex& c2)
 198 {
 199     if (mag(c1) < mag(c2))
 200     {
 201         return c1;
 202     }
 203     else
 204     {
 205         return c2;
 206     }
 207 }
 208
 209
 210 inline complex limit(const complex& c1, const complex& c2)
 211 {
 212     return complex(limit(c1.re, c2.re), limit(c1.im, c2.im));
 213 }
 214
 215
 216 inline const complex& sum(const complex& c)
 217 {
 218     return c;
 219 }
 220
 221
 222 template<class Cmpt>
 223 class Tensor;
 224
 225 inline complex transform(const Tensor<scalar>&, const complex c)
 226 {
 227     return c;
 228 }
 229
 230
 231 // * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
 232
 233 inline complex operator+(const complex& c1, const complex& c2)
 234 {
 235     return complex
 236     (
 237         c1.re+c2.re,
 238         c1.im+c2.im
 239     );
 240 }
 241
 242
 243 inline complex operator-(const complex& c)
 244 {
 245     return complex
 246     (
 247         -c.re,
 248         -c.im
 249     );
 250 }
 251
 252
 253 inline complex operator-(const complex& c1, const complex& c2)
 254 {
 255     return complex
 256     (
 257         c1.re-c2.re,
 258         c1.im-c2.im
 259     );
 260 }
 261
 262
 263 inline complex operator*(const complex& c1, const complex& c2)
 264 {
 265     return complex
 266     (
 267         c1.re*c2.re - c1.im*c2.im,
 268         c1.im*c2.re + c1.re*c2.im
 269     );
 270 }
 271
 272
 273 inline complex operator/(const complex& c1, const complex& c2)
 274 {
 275     scalar sqrC2 = magSqr(c2);
 276
 277     return complex
 278     (
 279         (c1.re*c2.re + c1.im*c2.im)/sqrC2,
 280         (c1.im*c2.re - c1.re*c2.im)/sqrC2
 281     );
 282 }
 283
 284
 285 inline complex operator*(const scalar s, const complex& c)
 286 {
 287     return complex(s*c.re, s*c.im);
 288 }
 289
 290
 291 inline complex operator*(const complex& c, const scalar s)
 292 {
 293     return complex(s*c.re, s*c.im);
 294 }
 295
 296
 297 inline complex operator/(const complex& c, const scalar s)
 298 {
 299     return complex(c.re/s, c.im/s);
 300 }
 301
 302
 303 inline complex operator/(const scalar s, const complex& c)
 304 {
 305     return complex(s/c.re, s/c.im);
 306 }
 307
 308
 309 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 310
 311 } // End namespace Foam
 312
 313 // ************************************************************************* //