G+Smo  24.08.0
Geometry + Simulation Modules
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
exprtk_codi_adaptor.h
Go to the documentation of this file.
1 
15 #define TYPE_TAG_(CODI_TYPE) CODI_TYPE ## _type_tag
16 #define TYPE_TAG(CODI_TYPE) TYPE_TAG_(CODI_TYPE)
17 #define CODI_TYPE_TAG TYPE_TAG(CODI_TYPE)
18 
19 namespace exprtk
20 {
21 namespace details
22 {
23 namespace numeric
24 {
25 namespace details
26 {
27 struct CODI_TYPE_TAG {};
28 
29 template<> struct number_type<CODI_TYPE> { typedef CODI_TYPE_TAG type; };
30 
31 template <>
32 struct epsilon_type<CODI_TYPE_TAG>
33 {
34  static inline CODI_TYPE::Real value()
35  {
36  static const CODI_TYPE::Real epsilon =
37  std::numeric_limits<CODI_TYPE::Real>::epsilon();
38  return epsilon;
39  }
40 };
41 
42 inline bool is_nan_impl(const CODI_TYPE& v, CODI_TYPE_TAG)
43 {
44  return std::isnan(v.getValue());
45 }
46 
47 template <typename T>
48 inline int to_int32_impl(const T& v, CODI_TYPE_TAG)
49 {
50  return static_cast<int>(v.getValue());
51 }
52 
53 template <typename T>
54 inline long long to_int64_impl(const T& v, CODI_TYPE_TAG)
55 {
56  return static_cast<long long int>(v.getValue());
57 }
58 
59 template <typename T> inline T abs_impl(const T& v, CODI_TYPE_TAG) { return abs (v); }
60 template <typename T> inline T acos_impl(const T& v, CODI_TYPE_TAG) { return acos (v); }
61 template <typename T> inline T acosh_impl(const T& v, CODI_TYPE_TAG) { return acosh(v); }
62 template <typename T> inline T asin_impl(const T& v, CODI_TYPE_TAG) { return asin (v); }
63 template <typename T> inline T asinh_impl(const T& v, CODI_TYPE_TAG) { return asinh(v); }
64 template <typename T> inline T atan_impl(const T& v, CODI_TYPE_TAG) { return atan (v); }
65 template <typename T> inline T atanh_impl(const T& v, CODI_TYPE_TAG) { return atanh(v); }
66 template <typename T> inline T ceil_impl(const T& v, CODI_TYPE_TAG) { return ceil (v); }
67 template <typename T> inline T cos_impl(const T& v, CODI_TYPE_TAG) { return cos (v); }
68 template <typename T> inline T cosh_impl(const T& v, CODI_TYPE_TAG) { return cosh (v); }
69 template <typename T> inline T exp_impl(const T& v, CODI_TYPE_TAG) { return exp (v); }
70 template <typename T> inline T floor_impl(const T& v, CODI_TYPE_TAG) { return floor(v); }
71 template <typename T> inline T log_impl(const T& v, CODI_TYPE_TAG) { return log (v); }
72 template <typename T> inline T log10_impl(const T& v, CODI_TYPE_TAG) { return log10(v); }
73 template <typename T> inline T log2_impl(const T& v, CODI_TYPE_TAG) { return log2 (v); }
74 template <typename T> inline T neg_impl(const T& v, CODI_TYPE_TAG) { return -v; }
75 template <typename T> inline T pos_impl(const T& v, CODI_TYPE_TAG) { return v; }
76 template <typename T> inline T sin_impl(const T& v, CODI_TYPE_TAG) { return sin (v); }
77 template <typename T> inline T sinh_impl(const T& v, CODI_TYPE_TAG) { return sinh (v); }
78 template <typename T> inline T sqrt_impl(const T& v, CODI_TYPE_TAG) { return sqrt (v); }
79 template <typename T> inline T tan_impl(const T& v, CODI_TYPE_TAG) { return tan (v); }
80 template <typename T> inline T tanh_impl(const T& v, CODI_TYPE_TAG) { return tanh (v); }
81 template <typename T> inline T cot_impl(const T& v, CODI_TYPE_TAG) { return cot (v); }
82 template <typename T> inline T sec_impl(const T& v, CODI_TYPE_TAG) { return sec (v); }
83 template <typename T> inline T csc_impl(const T& v, CODI_TYPE_TAG) { return csc (v); }
84 template <typename T> inline T r2d_impl(const T& v, CODI_TYPE_TAG) { return (v * exprtk::details::constant_codi::_180_pi); }
85 template <typename T> inline T d2r_impl(const T& v, CODI_TYPE_TAG) { return (v * exprtk::details::constant_codi::pi_180 ); }
86 template <typename T> inline T d2g_impl(const T& v, CODI_TYPE_TAG) { return (v * CODI_TYPE(20.0/9.0)); }
87 template <typename T> inline T g2d_impl(const T& v, CODI_TYPE_TAG) { return (v * CODI_TYPE(9.0/20.0)); }
88 template <typename T> inline T notl_impl(const T& v, CODI_TYPE_TAG) { return (v != CODI_TYPE(0) ? CODI_TYPE(0) : CODI_TYPE(1)); }
89 template <typename T> inline T frac_impl(const T& v, CODI_TYPE_TAG) { return frac (v); }
90 template <typename T> inline T trunc_impl(const T& v, CODI_TYPE_TAG) { return trunc(v); }
91 
92 template <typename T> inline T const_pi_impl(CODI_TYPE_TAG) { return exprtk::details::constant_codi::pi; }
93 template <typename T> inline T const_e_impl (CODI_TYPE_TAG) { return exprtk::details::constant_codi::e; }
94 
95 inline bool is_true_impl (const CODI_TYPE& v)
96 {
97  return 0.0 != v.getValue();
98 }
99 
100 inline bool is_false_impl(const CODI_TYPE& v)
101 {
102  return !is_true_impl(v);
103 }
104 
105 template <typename T>
106 inline T expm1_impl(const T& v, CODI_TYPE_TAG)
107 {
108  return expm1(v);
109 }
110 
111 template <typename T>
112 inline T min_impl(const T& v0, const T& v1, CODI_TYPE_TAG)
113 {
114  //using std::min;
115  return codi::min(v0,v1);
116 }
117 
118 template <typename T>
119 inline T max_impl(const T& v0, const T& v1, CODI_TYPE_TAG)
120 {
121  //using std::max;
122  return codi::max(v0,v1);
123 }
124 
125 template <typename T>
126 inline T nequal_impl(const T& v0, const T& v1, CODI_TYPE_TAG)
127 {
128  const T epsilon = epsilon_type<CODI_TYPE_TAG>::value();
129  const T eps_norm = (codi::max(T(1),codi::max(abs(v0),abs(v1))) * epsilon);
130  return (abs(T(v0 - v1)) > eps_norm) ? T(1) : T(0);
131 }
132 
133 template <typename T>
134 inline T sgn_impl(const T& v, CODI_TYPE_TAG)
135 {
136  if (v > T(0)) return T(+1);
137  else if (v < T(0)) return T(-1);
138  else return T( 0);
139 }
140 
141 template <typename T>
142 inline T log1p_impl(const T& v, CODI_TYPE_TAG)
143 {
144  return log1p(v);
145 }
146 
147 template <typename T>
148 inline T erf_impl(const T& v, CODI_TYPE_TAG)
149 {
150  return erf(v);
151 }
152 
153 template <typename T>
154 inline T erfc_impl(const T& v, CODI_TYPE_TAG)
155 {
156  return erfc(v);
157 }
158 
159 template <typename T>
160 inline T ncdf_impl(const T& v, CODI_TYPE_TAG)
161 {
162  T cnd = T(0.5) * (T(1) + codi::erf(
163  abs(v) /
164  T(exprtk::details::constant_codi::sqrt2)));
165  return (v < T(0)) ? (T(1) - cnd) : cnd;
166 }
167 
168 template <typename T>
169 inline T modulus_impl(const T& v0, const T& v1, CODI_TYPE_TAG)
170 {
171  std::cerr<<"modulus is not derivated\n";
172  return T(std::fmod(v0.getValue(),v1.getValue()));
173 }
174 
175 template <typename T>
176 inline T pow_impl(const T& v0, const T& v1, CODI_TYPE_TAG)
177 {
178  return pow(v0, v1.getValue() );// note: exponent considered constant
179 }
180 
181 template <typename T>
182 inline T logn_impl(const T& v0, const T& v1, CODI_TYPE_TAG)
183 {
184  return log(v0) / log(v1);
185 }
186 
187 template <typename T>
188 inline T sinc_impl(const T& v, CODI_TYPE_TAG)
189 {
190  if (abs(v) >= epsilon_type<CODI_TYPE_TAG>::value())
191  return(sin(v) / v);
192  else
193  return T(1);
194 }
195 
196 template <typename T>
197 inline T xor_impl(const T& v0, const T& v1, CODI_TYPE_TAG)
198 {
199  return (is_false_impl(v0) != is_false_impl(v1)) ? T(1) : T(0);
200 }
201 
202 template <typename T>
203 inline T xnor_impl(const T& v0, const T& v1, CODI_TYPE_TAG)
204 {
205  const bool v0_true = is_true_impl(v0);
206  const bool v1_true = is_true_impl(v1);
207  if ((v0_true && v1_true) || (!v0_true && !v1_true))
208  return T(1);
209  else
210  return T(0);
211 }
212 
213 template <typename T>
214 inline T equal_impl(const T& v0, const T& v1, CODI_TYPE_TAG)
215 {
216  const T epsilon = epsilon_type<CODI_TYPE_TAG>::value();
217  const T eps_norm = (codi::max(T(1),codi::max(abs(v0),abs(v1))) * epsilon);
218  return (abs(T(v0-v1)) <= eps_norm) ? T(1) : T(0);
219 }
220 
221 template <typename T>
222 inline T round_impl(const T& v, CODI_TYPE_TAG)
223 {
224  return round(v);
225 }
226 
227 template <typename T>
228 inline T roundn_impl(const T& v0, const T& v1, CODI_TYPE_TAG)
229 {
230  const T p10 = pow(T(10),floor(v1));
231  if (v0 < T(0))
232  return T(ceil (T((v0 * p10) - T(0.5))) / p10);
233  else
234  return T(floor(T((v0 * p10) + T(0.5))) / p10);
235 }
236 
237 template <typename T>
238 inline bool is_integer_impl(const T& v, CODI_TYPE_TAG)
239 {
240  return std::ceil(v.getValue()) == v.getValue();
241 }
242 
243 template <typename T>
244 inline T root_impl(const T& v0, const T& v1, CODI_TYPE_TAG)
245 {
246  return pow(v0,T(1) / v1);
247 }
248 
249 template <typename T>
250 inline T hypot_impl(const T& v0, const T& v1, CODI_TYPE_TAG)
251 {
252  return hypot(v0,v1);
253 }
254 
255 template <typename T>
256 inline T atan2_impl(const T& v0, const T& v1, CODI_TYPE_TAG)
257 {
258  return atan2(v0,v1);
259 }
260 
261 template <typename T>
262 inline T shr_impl(const T& v0, const T& v1, CODI_TYPE_TAG)
263 {
264  return v0 * (T(1) / pow(T(2.0),v1));
265 }
266 
267 template <typename T>
268 inline T shl_impl(const T& v0, const T& v1, CODI_TYPE_TAG)
269 {
270  return v0 * pow(T(2.0),v1);
271 }
272 
273 template <typename T>
274 inline T and_impl(const T& v0, const T& v1, CODI_TYPE_TAG)
275 {
276  return (is_true_impl(v0) && is_true_impl(v1)) ? T(1) : T(0);
277 }
278 
279 template <typename T>
280 inline T nand_impl(const T& v0, const T& v1, CODI_TYPE_TAG)
281 {
282  return (is_false_impl(v0) || is_false_impl(v1)) ? T(1) : T(0);
283 }
284 
285 template <typename T>
286 inline T or_impl(const T& v0, const T& v1, CODI_TYPE_TAG)
287 {
288  return (is_true_impl(v0) || is_true_impl(v1)) ? T(1) : T(0);
289 }
290 
291 template <typename T>
292 inline T nor_impl(const T& v0, const T& v1, CODI_TYPE_TAG)
293 {
294  return (is_false_impl(v0) && is_false_impl(v1)) ? T(1) : T(0);
295 }
296 }
297 }
298 
299 template <typename Iterator>
300 inline bool string_to_real(Iterator& itr_external,
301  const Iterator end, CODI_TYPE& t,
302  numeric::details::CODI_TYPE_TAG)
303 {
304  const std::string num(itr_external,end);
305  t = ::atof(num.c_str());
306  return true;
307 }
308 
309 inline bool is_true (const CODI_TYPE& v)
310 { return details::numeric::details::is_true_impl (v); }
311 
312 inline bool is_false(const CODI_TYPE& v)
313 { return details::numeric::details::is_false_impl(v); }
314 }
315 
316 namespace helper
317 {
318 namespace details
319 {
320 inline void print_type(const std::string&, const CODI_TYPE& v,
321  exprtk::details::numeric::details::CODI_TYPE_TAG)
322 {
323  printf("%f",v.getValue());
324 }
325 } // namespace numeric
326 } // namespace details
327 } // namespace exprtk
EIGEN_STRONG_INLINE abs_expr< E > abs(const E &u)
Absolute value.
Definition: gsExpressions.h:4486