www.cemf.ir
types.hpp
Go to the documentation of this file.
1 /*------------------------------- phasicFlow ---------------------------------
2  O C enter of
3  O O E ngineering and
4  O O M ultiscale modeling of
5  OOOOOOO F luid flow
6 ------------------------------------------------------------------------------
7  Copyright (C): www.cemf.ir
8  email: hamid.r.norouzi AT gmail.com
9 ------------------------------------------------------------------------------
10 Licence:
11  This file is part of phasicFlow code. It is a free software for simulating
12  granular and multiphase flows. You can redistribute it and/or modify it under
13  the terms of GNU General Public License v3 or any other later versions.
14 
15  phasicFlow is distributed to help others in their research in the field of
16  granular and multiphase flows, but WITHOUT ANY WARRANTY; without even the
17  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
18 
19 -----------------------------------------------------------------------------*/
20 
21 #ifndef __types_hpp__
22 #define __types_hpp__
23 
24 #include "bTypes.hpp"
25 
26 #include "bTypesFunctions.hpp"
27 
28 #include "triple.hpp"
29 
30 #include "quadruple.hpp"
31 
32 #include "typeInfo.hpp"
33 
34 namespace pFlow
35 {
36 
37 using int8x3 = triple<int8>;
38 using int32x3 = triple<int32>;
39 using int64x3 = triple<int64>;
40 using uint8x3 = triple<uint8>;
41 using uint32x3 = triple<uint32>;
42 using uint64x3 = triple<uint64>;
43 using realx3 = triple<real>;
44 
45 using int32x3x3 = triple<int32x3>;
46 using uint32x3x3 = triple<uint32x3>;
47 using realx3x3 = triple<realx3>;
48 
49 using realx4 = quadruple<real>;
50 
51 using realx4x3 = quadruple<realx3>;
52 
53 /*template<>
54 inline word
55 triple<int8>::TYPENAME()
56 {
57  return "int8x3";
58 }
59 
60 template<>
61 inline word
62 triple<int32>::TYPENAME()
63 {
64  return "int32x3";
65 }
66 
67 template<>
68 inline word
69 basicTypeName<int64x3>()
70 {
71  return "int64x3";
72 }
73 
74 template<>
75 inline word
76 basicTypeName<uint8x3>()
77 {
78  return "uint8x3";
79 }
80 
81 template<>
82 inline word
83 basicTypeName<uint32x3>()
84 {
85  return "uint32x3";
86 }
87 
88 template<>
89 inline word
90 basicTypeName<uint64x3>()
91 {
92  return "unit64x3";
93 }
94 
95 template<>
96 inline word
97 basicTypeName<realx3>()
98 {
99  return "realx3";
100 }
101 
102 template<>
103 inline word
104 basicTypeName<int32x3x3>()
105 {
106  return "int32x3x3";
107 }
108 
109 template<>
110 inline word
111 basicTypeName<uint32x3x3>()
112 {
113  return "uint32x3x3";
114 }
115 
116 template<>
117 inline word
118 basicTypeName<realx3x3>()
119 {
120  return "realx3x3";
121 }
122 
123 template<>
124 inline word
125 basicTypeName<realx4>()
126 {
127  return "realx4";
128 }
129 
130 template<>
131 inline word
132 basicTypeName<realx4x3>()
133 {
134  return "realx4x3";
135 }*/
136 
137 extern const realx3 zero3;
138 extern const realx3 one3;
139 
140 extern const realx3x3 zero33;
141 extern const realx3x3 one33;
142 
143 extern const realx4 zero4;
144 
145 } // pFlow
146 
147 #endif //__types_hpp__
pFlow::zero33
const realx3x3 zero33(zero3)
Definition: types.hpp:140
pFlow::zero3
const realx3 zero3(0.0)
Definition: types.hpp:137
pFlow::one3
const realx3 one3(1.0)
Definition: types.hpp:138
quadruple.hpp
bTypes.hpp
pFlow
Definition: demGeometry.hpp:27
pFlow::one33
const realx3x3 one33(one3)
Definition: types.hpp:141
triple.hpp
typeInfo.hpp
pFlow::quadruple
Definition: quadruple.hpp:36
pFlow::zero4
const realx4 zero4(zero)
Definition: types.hpp:143
bTypesFunctions.hpp
pFlow::triple
A set of 3 variables that can be used for vector variables.
Definition: triple.hpp:36