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