applications/utilities/postProcessing/dataConversion/foamToFieldview9/floatScalar.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | foam-extend: Open Source CFD
   4    \\    /   O peration     | Version:     3.2
   5     \\  /    A nd           | Web:         http://www.foam-extend.org
   6      \\/     M anipulation  | For copyright notice see file Copyright
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of foam-extend.
  10
  11     foam-extend 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 3 of the License, or (at your
  14     option) any later version.
  15
  16     foam-extend is distributed in the hope that it will be useful, but
  17     WITHOUT ANY WARRANTY; without even the implied warranty of
  18     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19     General Public License for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 Typedef
  25     Foam::floatScalar
  26
  27 Description
  28     single floating point number identical to float
  29
  30 SourceFiles
  31     floatScalar.C
  32
  33 \*---------------------------------------------------------------------------*/
  34
  35 #ifndef floatScalar_H
  36 #define floatScalar_H
  37
  38 #include "label.H"
  39 #include "word.H"
  40
  41 #include <cmath>
  42
  43 #ifdef ibm
  44     float lgamma(float);
  45 #endif
  46
  47 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  48 // Define floatScalar as a float
  49
  50 namespace Foam
  51 {
  52     typedef float floatScalar;
  53 }
  54
  55 /*
  56 // Define floatScalar as a float
  57
  58 namespace Foam
  59 {
  60     typedef float floatScalar;
  61
  62     // Largest and smallest floatScalar values allowed in certain parts of the code
  63     // (6 is the number of significant figures in an
  64     //  IEEE single precision number.  See limits.h or float.h)
  65     static const floatScalar GREAT = 1.0e+6;
  66     static const floatScalar VGREAT = 1.0e+37;
  67     static const floatScalar SMALL = 1.0e-6;
  68     static const floatScalar VSMALL = 1.0e-37;
  69 }
  70 */
  71
  72 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  73
  74 #include "pTraits.H"
  75 #include "products.H"
  76 #include "direction.H"
  77
  78 namespace Foam
  79 {
  80
  81 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  82
  83 // template specialisation for pTraits<floatScalar>
  84 template<>
  85 class pTraits<floatScalar>
  86 {
  87     floatScalar p_;
  88
  89 public:
  90
  91     //- Component type
  92     typedef floatScalar cmptType;
  93
  94     // Member constants
  95
  96         enum
  97         {
  98             dim = 3,         // Dimensionality of space
  99             rank = 0,        // Rank od floatScalar is 0
 100             nComponents = 1  // Number of components in floatScalar is 1
 101         };
 102
 103     // Static data members
 104
 105         static const char* const typeName;
 106         static const char* componentNames[];
 107         static const floatScalar zero;
 108         static const floatScalar one;
 109
 110     // Constructors
 111
 112         //- Construct from Istream
 113         pTraits(Istream& is);
 114
 115     // Member Functions
 116
 117         operator floatScalar() const
 118         {
 119             return p_;
 120         }
 121 };
 122
 123
 124 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 125
 126 //template<class Cmpt>
 127 //class typeOfRank<Cmpt, 0>
 128 //{
 129 //public:
 130 //
 131 //    typedef Cmpt type;
 132 //};
 133
 134
 135 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 136
 137 // Return a string representation of a floatScalar
 138 word name(const floatScalar s)
 139 {
 140     return name(scalar(s));
 141 }
 142
 143 #define MAXMINPOW(retType, type1, type2)          \
 144                                                   \
 145 MAXMIN(retType, type1, type2)                     \
 146                                                   \
 147 inline float pow(const type1 s, const type2 e)   \
 148 {                                                 \
 149     return ::pow(float(s), float(e));           \
 150 }
 151
 152
 153 //MAXMINPOW(float, float, float)
 154 //MAXMINPOW(float, float, int)
 155 //MAXMINPOW(float, int, float)
 156 //MAXMINPOW(float, float, long)
 157 //MAXMINPOW(float, long, float)
 158 //MAXMINPOW(float, float, int)
 159 //MAXMINPOW(float, int, float)
 160 //MAXMINPOW(float, float, long)
 161 //MAXMINPOW(float, long, float)
 162
 163 #undef MAXMINPOW
 164
 165
 166 inline floatScalar mag(const floatScalar s)
 167 {
 168     return ::fabs(s);
 169 }
 170
 171 inline floatScalar sign(const floatScalar s)
 172 {
 173     return (s >= 0)? 1: -1;
 174 }
 175
 176 inline floatScalar pos(const floatScalar s)
 177 {
 178     return (s >= 0)? 1: 0;
 179 }
 180
 181 inline floatScalar neg(const floatScalar s)
 182 {
 183     return (s < 0)? 1: 0;
 184 }
 185
 186 inline floatScalar limit(const floatScalar s1, const floatScalar s2)
 187 {
 188     return (mag(s1) < mag(s2))? s1: 0.0;
 189 }
 190
 191 inline floatScalar magSqr(const floatScalar s)
 192 {
 193     return s*s;
 194 }
 195
 196 inline floatScalar sqr(const floatScalar s)
 197 {
 198     return s*s;
 199 }
 200
 201 inline floatScalar pow3(const floatScalar s)
 202 {
 203     return s*s*s;
 204 }
 205
 206 inline floatScalar pow4(const floatScalar s)
 207 {
 208     return sqr(sqr(s));
 209 }
 210
 211 inline floatScalar cmptAv(const floatScalar s)
 212 {
 213     return s;
 214 }
 215
 216 inline floatScalar cmptMag(const floatScalar s)
 217 {
 218     return mag(s);
 219 }
 220
 221 inline floatScalar scale(const floatScalar s, const floatScalar d)
 222 {
 223     return s*d;
 224 }
 225
 226
 227 #define transFunc(func)            \
 228 inline floatScalar func(const floatScalar s) \
 229 {                                  \
 230     return ::func(s);              \
 231 }
 232
 233 // Standard C++ transcendental functions
 234 transFunc(sqrt)
 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 transFunc(erf)
 253 transFunc(erfc)
 254 transFunc(lgamma)
 255 transFunc(j0)
 256 transFunc(j1)
 257 transFunc(y0)
 258 transFunc(y1)
 259
 260 #undef transFunc
 261
 262 // Stabilisation around zero for division
 263 inline floatScalar stabilise(const floatScalar s, const floatScalar small)
 264 {
 265     if (s >= 0)
 266     {
 267         return s + small;
 268     }
 269     else
 270     {
 271         return s - small;
 272     }
 273 }
 274
 275
 276 // * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
 277
 278 //floatScalar readScalar(Istream& is);
 279 Istream& operator>>(Istream&, floatScalar&);
 280 Ostream& operator<<(Ostream&, const floatScalar);
 281
 282 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 283
 284 } // End namespace Foam
 285
 286 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 287
 288 #endif
 289
 290 // ************************************************************************* //