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