src/OpenFOAM/primitives/complex/complex.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 Class
  26     Foam::complex
  27
  28 Description
  29     Extension to the c++ complex library type.
  30
  31 SourceFiles
  32     complexI.H
  33     complex.C
  34
  35 \*---------------------------------------------------------------------------*/
  36
  37 #ifndef complex_H
  38 #define complex_H
  39
  40 #include "scalar.H"
  41 #include "bool.H"
  42 #include "word.H"
  43 #include "contiguous.H"
  44
  45 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  46
  47 namespace Foam
  48 {
  49
  50 // Forward declaration of friend functions and operators
  51
  52 class complex;
  53
  54 inline scalar magSqr(const complex&);
  55 inline complex sqr(const complex&);
  56 inline scalar mag(const complex&);
  57 inline const complex& max(const complex&, const complex&);
  58 inline const complex& min(const complex&, const complex&);
  59 inline complex limit(const complex&, const complex&);
  60 inline const complex& sum(const complex&);
  61 inline complex operator+(const complex&, const complex&);
  62 inline complex operator-(const complex&);
  63 inline complex operator-(const complex&, const complex&);
  64 inline complex operator*(const complex&, const complex&);
  65 inline complex operator/(const complex&, const complex&);
  66 inline complex operator*(const scalar, const complex&);
  67 inline complex operator*(const complex&, const scalar);
  68 inline complex operator/(const complex&, const scalar);
  69 inline complex operator/(const scalar, const complex&);
  70 Istream& operator>>(Istream&, complex&);
  71 Ostream& operator<<(Ostream&, const complex&);
  72
  73
  74 /*---------------------------------------------------------------------------*\
  75                            Class complex Declaration
  76 \*---------------------------------------------------------------------------*/
  77
  78 class complex
  79 {
  80     // private data
  81
  82         //- Real and imaginary parts of the complex number
  83         scalar re, im;
  84
  85 public:
  86
  87     //- Component type
  88     typedef complex cmptType;
  89
  90
  91     // Static data members
  92
  93         static const char* const typeName;
  94
  95         static const complex zero;
  96         static const complex one;
  97
  98
  99     // Constructors
 100
 101         //- Construct null
 102         inline complex();
 103
 104         //- Construct given real and imaginary parts
 105         inline complex(const scalar Re, const scalar Im);
 106
 107         //- Construct from Istream
 108         complex(Istream&);
 109
 110
 111     // Member functions
 112
 113            // Access
 114
 115                inline scalar Re() const;
 116                inline scalar Im() const;
 117
 118            // Edit
 119
 120                inline scalar& Re();
 121                inline scalar& Im();
 122
 123            // Operators
 124
 125                inline complex conjugate() const;
 126
 127
 128     // Member operators
 129
 130         inline const complex& operator=(const complex&);
 131         inline void operator+=(const complex&);
 132         inline void operator-=(const complex&);
 133         inline void operator*=(const complex&);
 134         inline void operator/=(const complex&);
 135
 136         inline const complex& operator=(const scalar);
 137         inline void operator+=(const scalar);
 138         inline void operator-=(const scalar);
 139         inline void operator*=(const scalar);
 140         inline void operator/=(const scalar);
 141
 142         inline complex operator!() const;
 143
 144         inline bool operator==(const complex&) const;
 145         inline bool operator!=(const complex&) const;
 146
 147
 148     // Friend functions
 149
 150         friend scalar magSqr(const complex& c);
 151         friend complex sqr(const complex& c);
 152         friend scalar mag(const complex& c);
 153         friend const complex& max(const complex&, const complex&);
 154         friend const complex& min(const complex&, const complex&);
 155
 156         friend complex limit(const complex&, const complex&);
 157
 158         friend const complex& sum(const complex&);
 159
 160
 161     // Friend operators
 162
 163         friend complex operator+(const complex&, const complex&);
 164         friend complex operator-(const complex&);
 165         friend complex operator-(const complex&, const complex&);
 166         friend complex operator*(const complex&, const complex&);
 167         friend complex operator/(const complex&, const complex&);
 168
 169         friend complex operator*(const scalar, const complex&);
 170         friend complex operator*(const complex&, const scalar);
 171         friend complex operator/(const complex&, const scalar);
 172         friend complex operator/(const scalar, const complex&);
 173
 174
 175     // IOstream operators
 176
 177         friend Istream& operator>>(Istream&, complex&);
 178         friend Ostream& operator<<(Ostream&, const complex&);
 179
 180 };
 181
 182
 183 // * * * * * * * * * * * * * * Global functions  * * * * * * * * * * * * * * //
 184
 185 //- Return a string representation of a complex
 186 word name(const complex&);
 187
 188
 189 //- Data associated with complex type are contiguous
 190 template<>
 191 inline bool contiguous<complex>() {return true;}
 192
 193
 194 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 195
 196 } // End namespace Foam
 197
 198 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 199
 200 #include "complexI.H"
 201
 202 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 203
 204 #endif
 205
 206 // ************************************************************************* //