doubleScalar.H
Go to the documentation of this file.
1 /*---------------------------------------------------------------------------*\
2  ========= |
3  \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
4  \\ / O peration | Website: https://openfoam.org
5  \\ / A nd | Copyright (C) 2011-2019 OpenFOAM Foundation
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
13  the Free Software Foundation, either version 3 of the License, or
14  (at your 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, see <http://www.gnu.org/licenses/>.
23 
24 Typedef
25  Foam::doubleScalar
26 
27 Description
28  Double precision floating point scalar type.
29 
30 SourceFiles
31  doubleScalar.C
32 
33 \*---------------------------------------------------------------------------*/
34 
35 #ifndef doubleScalar_H
36 #define doubleScalar_H
37 
38 #include "doubleFloat.H"
39 #include "direction.H"
40 #include "word.H"
41 
42 #include <limits>
43 using std::numeric_limits;
44 
45 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
46 
47 namespace Foam
48 {
49 
50 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
51 
52 typedef double doubleScalar;
53 
54 // Largest and smallest scalar values allowed in certain parts of the code.
55 static const doubleScalar doubleScalarVGreat
57 static const doubleScalar doubleScalarVSmall
59 
60 static const doubleScalar doubleScalarSmall
62 static const doubleScalar doubleScalarGreat
64 
65 static const doubleScalar doubleScalarRootVGreat = ::sqrt(doubleScalarVGreat);
66 static const doubleScalar doubleScalarRootVSmall = ::sqrt(doubleScalarVSmall);
67 
68 static const doubleScalar doubleScalarRootGreat = ::sqrt(doubleScalarGreat);
69 static const doubleScalar doubleScalarRootSmall = ::sqrt(doubleScalarSmall);
70 
71 static const doubleScalar doubleScalarNaN
72  = numeric_limits<doubleScalar>::signaling_NaN();
73 
74 //- Read whole of buf as a scalar. Return true if successful.
75 inline bool readScalar(const char* buf, doubleScalar& s)
76 {
77  char* endPtr;
78  s = strtod(buf, &endPtr);
79 
80  return (*endPtr == '\0');
81 }
82 
83 #define Scalar doubleScalar
84 #define ScalarVGreat doubleScalarVGreat
85 #define ScalarVSmall doubleScalarVSmall
86 #define ScalarRootVGreat doubleScalarRootVGreat
87 #define ScalarRootVSmall doubleScalarRootVSmall
88 #define readScalar readDoubleScalar
89 
90 inline Scalar mag(const Scalar s)
91 {
92  return ::fabs(s);
93 }
94 
95 
96 #define MAXMINPOW(retType, type1, type2) \
97  \
98 MAXMIN(retType, type1, type2) \
99  \
100 inline double pow(const type1 s, const type2 e) \
101 { \
102  return ::pow(Scalar(s), Scalar(e)); \
103 }
104 
106 MAXMINPOW(Scalar, Scalar, int)
107 MAXMINPOW(Scalar, int, Scalar)
108 MAXMINPOW(Scalar, Scalar, long)
109 MAXMINPOW(Scalar, long, Scalar)
110 MAXMINPOW(Scalar, Scalar, float)
111 MAXMINPOW(Scalar, float, Scalar)
112 
113 #undef MAXMINPOW
114 
115 #define transFunc(func) \
116 inline Scalar func(const Scalar s) \
117 { \
118  return ::func(s); \
119 }
120 
121 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
122 
123 } // End namespace Foam
124 
125 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
126 
127 #include "Scalar.H"
128 
129 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
130 
131 namespace Foam
132 {
133 
134 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
135 
136 inline Scalar hypot(const Scalar x, const Scalar y)
137 {
138  return ::hypot(x, y);
139 }
140 
141 inline Scalar atan2(const Scalar y, const Scalar x)
142 {
143  return ::atan2(y, x);
144 }
145 
146 inline Scalar jn(const int n, const Scalar s)
147 {
148  return ::jn(n, s);
149 }
150 
151 inline Scalar yn(const int n, const Scalar s)
152 {
153  return ::yn(n, s);
154 }
155 
156 #undef Scalar
157 #undef ScalarVGreat
158 #undef ScalarVSmall
159 #undef ScalarRootVGreat
160 #undef ScalarRootVSmall
161 #undef readScalar
162 #undef transFunc
163 
164 
165 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
166 
167 } // End namespace Foam
168 
169 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
170 
171 #endif
172 
173 // ************************************************************************* //
layerAndWeight max(const layerAndWeight &a, const layerAndWeight &b)
#define Scalar
Definition: doubleScalar.H:83
doubleScalar jn(const int n, const doubleScalar s)
Definition: doubleScalar.H:146
#define MAXMINPOW(retType, type1, type2)
Definition: doubleScalar.H:96
static const doubleScalar doubleScalarNaN
Definition: doubleScalar.H:72
dimensionedScalar yn(const int n, const dimensionedScalar &ds)
dimensionedScalar sqrt(const dimensionedScalar &ds)
doubleScalar yn(const int n, const doubleScalar s)
Definition: doubleScalar.H:151
static const doubleScalar doubleScalarGreat
Definition: doubleScalar.H:63
static const doubleScalar doubleScalarVSmall
Definition: doubleScalar.H:58
scalar y
gmvFile<< "tracers "<< particles.size()<< nl;forAllConstIter(Cloud< passiveParticle >, particles, iter){ gmvFile<< iter().position().x()<< " ";}gmvFile<< nl;forAllConstIter(Cloud< passiveParticle >, particles, iter){ gmvFile<< iter().position().y()<< " ";}gmvFile<< nl;forAllConstIter(Cloud< passiveParticle >, particles, iter){ gmvFile<< iter().position().z()<< " ";}gmvFile<< nl;forAll(lagrangianScalarNames, i){ word name=lagrangianScalarNames[i];IOField< scalar > s(IOobject(name, runTime.timeName(), cloud::prefix, mesh, IOobject::MUST_READ, IOobject::NO_WRITE))
dimensionedScalar jn(const int n, const dimensionedScalar &ds)
double doubleScalar
Double precision floating point scalar type.
Definition: doubleScalar.H:52
layerAndWeight min(const layerAndWeight &a, const layerAndWeight &b)
bool readScalar(const char *buf, doubleScalar &s)
Read whole of buf as a scalar. Return true if successful.
Definition: doubleScalar.H:75
dimensionedScalar atan2(const dimensionedScalar &x, const dimensionedScalar &y)
doubleScalar atan2(const doubleScalar y, const doubleScalar x)
Definition: doubleScalar.H:141
static const doubleScalar doubleScalarSmall
Definition: doubleScalar.H:61
doubleScalar hypot(const doubleScalar x, const doubleScalar y)
Definition: doubleScalar.H:136
Direction is an 8-bit unsigned integer type used to represent the Cartesian directions etc...
scalar epsilon
dimensioned< scalar > mag(const dimensioned< Type > &)
label n
dimensionedScalar hypot(const dimensionedScalar &x, const dimensionedScalar &y)
Namespace for OpenFOAM.
static const doubleScalar doubleScalarVGreat
Definition: doubleScalar.H:56