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