applications/utilities/postProcessing/dataConversion/foamToFieldview9/floatScalar.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::floatScalar
  27
  28 Description
  29     single floating point number identical to float
  30
  31 SourceFiles
  32     floatScalar.C
  33
  34 \*---------------------------------------------------------------------------*/
  35
  36 #ifndef floatScalar_H
  37 #define floatScalar_H
  38
  39 #include "label.H"
  40 #include "word.H"
  41
  42 #include <cmath>
  43
  44 #ifdef ibm
  45     float lgamma(float);
  46 #endif
  47
  48 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  49 // Define floatScalar as a float
  50
  51 namespace Foam
  52 {
  53     typedef float floatScalar;
  54 }
  55
  56 /*
  57 // Define floatScalar as a float
  58
  59 namespace Foam
  60 {
  61     typedef float floatScalar;
  62
  63     // Largest and smallest floatScalar values allowed in certain parts of the code
  64     // (6 is the number of significant figures in an
  65     //  IEEE single precision number.  See limits.h or float.h)
  66     static const floatScalar GREAT = 1.0e+6;
  67     static const floatScalar VGREAT = 1.0e+37;
  68     static const floatScalar SMALL = 1.0e-6;
  69     static const floatScalar VSMALL = 1.0e-37;
  70 }
  71 */
  72
  73 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  74
  75 #include "pTraits.H"
  76 #include "products.H"
  77 #include "direction.H"
  78
  79 namespace Foam
  80 {
  81
  82 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  83
  84 // template specialisation for pTraits<floatScalar>
  85 template<>
  86 class pTraits<floatScalar>
  87 {
  88     floatScalar p_;
  89
  90 public:
  91
  92     //- Component type
  93     typedef floatScalar cmptType;
  94
  95     // Member constants
  96
  97         enum
  98         {
  99             dim = 3,         // Dimensionality of space
 100             rank = 0,        // Rank od floatScalar is 0
 101             nComponents = 1  // Number of components in floatScalar is 1
 102         };
 103
 104     // Static data members
 105
 106         static const char* const typeName;
 107         static const char* componentNames[];
 108         static const floatScalar zero;
 109         static const floatScalar one;
 110
 111     // Constructors
 112
 113         //- Construct from Istream
 114         pTraits(Istream& is);
 115
 116     // Member Functions
 117
 118         operator floatScalar() const
 119         {
 120             return p_;
 121         }
 122 };
 123
 124
 125 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 126
 127 //template<class Cmpt>
 128 //class typeOfRank<Cmpt, 0>
 129 //{
 130 //public:
 131 //
 132 //    typedef Cmpt type;
 133 //};
 134
 135
 136 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 137
 138 // Return a string representation of a floatScalar
 139 word name(const floatScalar s)
 140 {
 141     return name(scalar(s));
 142 }
 143
 144 #define MAXMINPOW(retType, type1, type2)          \
 145                                                   \
 146 MAXMIN(retType, type1, type2)                     \
 147                                                   \
 148 inline float pow(const type1 s, const type2 e)   \
 149 {                                                 \
 150     return ::pow(float(s), float(e));           \
 151 }
 152
 153
 154 //MAXMINPOW(float, float, float)
 155 //MAXMINPOW(float, float, int)
 156 //MAXMINPOW(float, int, float)
 157 //MAXMINPOW(float, float, long)
 158 //MAXMINPOW(float, long, float)
 159 //MAXMINPOW(float, float, int)
 160 //MAXMINPOW(float, int, float)
 161 //MAXMINPOW(float, float, long)
 162 //MAXMINPOW(float, long, float)
 163
 164 #undef MAXMINPOW
 165
 166
 167 inline floatScalar mag(const floatScalar s)
 168 {
 169     return ::fabs(s);
 170 }
 171
 172 inline floatScalar sign(const floatScalar s)
 173 {
 174     return (s >= 0)? 1: -1;
 175 }
 176
 177 inline floatScalar pos(const floatScalar s)
 178 {
 179     return (s >= 0)? 1: 0;
 180 }
 181
 182 inline floatScalar neg(const floatScalar s)
 183 {
 184     return (s < 0)? 1: 0;
 185 }
 186
 187 inline floatScalar limit(const floatScalar s1, const floatScalar s2)
 188 {
 189     return (mag(s1) < mag(s2))? s1: 0.0;
 190 }
 191
 192 inline floatScalar magSqr(const floatScalar s)
 193 {
 194     return s*s;
 195 }
 196
 197 inline floatScalar sqr(const floatScalar s)
 198 {
 199     return s*s;
 200 }
 201
 202 inline floatScalar pow3(const floatScalar s)
 203 {
 204     return s*s*s;
 205 }
 206
 207 inline floatScalar pow4(const floatScalar s)
 208 {
 209     return sqr(sqr(s));
 210 }
 211
 212 inline floatScalar cmptAv(const floatScalar s)
 213 {
 214     return s;
 215 }
 216
 217 inline floatScalar cmptMag(const floatScalar s)
 218 {
 219     return mag(s);
 220 }
 221
 222 inline floatScalar scale(const floatScalar s, const floatScalar d)
 223 {
 224     return s*d;
 225 }
 226
 227
 228 #define transFunc(func)            \
 229 inline floatScalar func(const floatScalar s) \
 230 {                                  \
 231     return ::func(s);              \
 232 }
 233
 234 // Standard C++ transcendental functions
 235 transFunc(sqrt)
 236 transFunc(exp)
 237 transFunc(log)
 238 transFunc(log10)
 239 transFunc(sin)
 240 transFunc(cos)
 241 transFunc(tan)
 242 transFunc(asin)
 243 transFunc(acos)
 244 transFunc(atan)
 245 transFunc(sinh)
 246 transFunc(cosh)
 247 transFunc(tanh)
 248 transFunc(asinh)
 249 transFunc(acosh)
 250 transFunc(atanh)
 251
 252 // Standard ANSI-C (but not in <cmath>) transcendental functions
 253 transFunc(erf)
 254 transFunc(erfc)
 255 transFunc(lgamma)
 256 transFunc(j0)
 257 transFunc(j1)
 258 transFunc(y0)
 259 transFunc(y1)
 260
 261 #undef transFunc
 262
 263 // Stabilisation around zero for division
 264 inline floatScalar stabilise(const floatScalar s, const floatScalar small)
 265 {
 266     if (s >= 0)
 267     {
 268         return s + small;
 269     }
 270     else
 271     {
 272         return s - small;
 273     }
 274 }
 275
 276
 277 // * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
 278
 279 //floatScalar readScalar(Istream& is);
 280 Istream& operator>>(Istream&, floatScalar&);
 281 Ostream& operator<<(Ostream&, const floatScalar);
 282
 283 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 284
 285 } // End namespace Foam
 286
 287 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 288
 289 #endif
 290
 291 // ************************************************************************* //