src/OpenFOAM/primitives/Scalar/Scalar.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 Typedef
  26     Foam::Scalar
  27
  28 Description
  29     Single floating point number
  30
  31 SourceFiles
  32     Scalar.C
  33
  34 \*---------------------------------------------------------------------------*/
  35
  36 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  37
  38 // template specialisation for pTraits<Scalar>
  39 template<>
  40 class pTraits<Scalar>
  41 {
  42     Scalar p_;
  43
  44 public:
  45
  46     //- Component type
  47     typedef Scalar cmptType;
  48
  49     // Member constants
  50
  51         enum
  52         {
  53             dim = 3,         // Dimensionality of space
  54             rank = 0,        // Rank od Scalar is 0
  55             nComponents = 1  // Number of components in Scalar is 1
  56         };
  57
  58     // Static data members
  59
  60         static const char* const typeName;
  61         static const char* componentNames[];
  62         static const Scalar zero;
  63         static const Scalar one;
  64
  65     // Constructors
  66
  67         //- Construct from Istream
  68         pTraits(Istream& is);
  69
  70     // Member Functions
  71
  72         operator Scalar() const
  73         {
  74             return p_;
  75         }
  76 };
  77
  78
  79 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  80
  81 // Return a string representation of a Scalar
  82 word name(const Scalar s);
  83
  84
  85 inline Scalar& setComponent(Scalar& s, const direction)
  86 {
  87     return s;
  88 }
  89
  90 inline Scalar component(const Scalar s, const direction)
  91 {
  92     return s;
  93 }
  94
  95 inline Scalar sign(const Scalar s)
  96 {
  97     return (s >= 0)? 1: -1;
  98 }
  99
 100 inline Scalar pos(const Scalar s)
 101 {
 102     return (s >= 0)? 1: 0;
 103 }
 104
 105 inline Scalar neg(const Scalar s)
 106 {
 107     return (s < 0)? 1: 0;
 108 }
 109
 110 inline bool equal(const Scalar& s1, const Scalar& s2)
 111 {
 112     return mag(s1 - s2) <= ScalarVSMALL;
 113 }
 114
 115 inline bool notEqual(const Scalar s1, const Scalar s2)
 116 {
 117     return mag(s1 - s2) > ScalarVSMALL;
 118 }
 119
 120 inline Scalar limit(const Scalar s1, const Scalar s2)
 121 {
 122     return (mag(s1) < mag(s2)) ? s1: 0.0;
 123 }
 124
 125 inline Scalar minMod(const Scalar s1, const Scalar s2)
 126 {
 127     return (mag(s1) < mag(s2)) ? s1: s2;
 128 }
 129
 130 inline Scalar magSqr(const Scalar s)
 131 {
 132     return s*s;
 133 }
 134
 135 inline Scalar sqr(const Scalar s)
 136 {
 137     return s*s;
 138 }
 139
 140 inline Scalar sqrtSumSqr(const Scalar a, const Scalar b)
 141 {
 142     Scalar maga = mag(a);
 143     Scalar magb = mag(b);
 144
 145     if (maga > magb)
 146     {
 147         return maga*sqrt(1.0 + sqr(magb/maga));
 148     }
 149     else
 150     {
 151         return magb < ScalarVSMALL ? 0.0 : magb*sqrt(1.0 + sqr(maga/magb));
 152     }
 153 }
 154
 155 inline Scalar pow3(const Scalar s)
 156 {
 157     return s*sqr(s);
 158 }
 159
 160 inline Scalar pow4(const Scalar s)
 161 {
 162     return sqr(sqr(s));
 163 }
 164
 165 inline Scalar pow5(const Scalar s)
 166 {
 167     return s*pow4(s);
 168 }
 169
 170 inline Scalar pow6(const Scalar s)
 171 {
 172     return pow3(sqr(s));
 173 }
 174
 175 inline Scalar inv(const Scalar s)
 176 {
 177     return 1.0/s;
 178 }
 179
 180 inline Scalar dot(const Scalar s1, const Scalar s2)
 181 {
 182     return s1*s2;
 183 }
 184
 185 inline Scalar cmptMultiply(const Scalar s1, const Scalar s2)
 186 {
 187     return s1*s2;
 188 }
 189
 190 inline Scalar cmptDivide(const Scalar s1, const Scalar s2)
 191 {
 192     return s1/s2;
 193 }
 194
 195 inline Scalar cmptMax(const Scalar s)
 196 {
 197     return s;
 198 }
 199
 200 inline Scalar cmptMin(const Scalar s)
 201 {
 202     return s;
 203 }
 204
 205 inline Scalar cmptAv(const Scalar s)
 206 {
 207     return s;
 208 }
 209
 210 inline Scalar cmptMag(const Scalar s)
 211 {
 212     return mag(s);
 213 }
 214
 215
 216 // Standard C++ transcendental functions
 217 transFunc(sqrt)
 218 transFunc(cbrt)
 219 transFunc(exp)
 220 transFunc(log)
 221 transFunc(log10)
 222 transFunc(sin)
 223 transFunc(cos)
 224 transFunc(tan)
 225 transFunc(asin)
 226 transFunc(acos)
 227 transFunc(atan)
 228 transFunc(sinh)
 229 transFunc(cosh)
 230 transFunc(tanh)
 231 transFunc(asinh)
 232 transFunc(acosh)
 233 transFunc(atanh)
 234
 235 // Standard ANSI-C (but not in <cmath>) transcendental functions
 236
 237 transFunc(erf)
 238 transFunc(erfc)
 239 transFunc(lgamma)
 240
 241 transFunc(j0)
 242 transFunc(j1)
 243
 244 transFunc(y0)
 245 transFunc(y1)
 246
 247
 248 // Stabilisation around zero for division
 249 inline Scalar stabilise(const Scalar s, const Scalar small)
 250 {
 251     if (s >= 0)
 252     {
 253         return s + small;
 254     }
 255     else
 256     {
 257         return s - small;
 258     }
 259 }
 260
 261
 262 // * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
 263
 264 Scalar readScalar(Istream& is);
 265 Istream& operator>>(Istream&, Scalar&);
 266 Ostream& operator<<(Ostream&, const Scalar);
 267
 268
 269 // ************************************************************************* //