16 #ifndef ONCE_FPARSER_AUX_H_ 17 #define ONCE_FPARSER_AUX_H_ 23 #ifdef FP_SUPPORT_MPFR_FLOAT_TYPE 27 #ifdef FP_SUPPORT_GMP_INT_TYPE 31 #ifdef FP_SUPPORT_COMPLEX_NUMBERS 35 #ifdef ONCE_FPARSER_H_ 41 enum { result =
false };
44 struct IsIntType<long>
46 enum { result =
true };
48 #ifdef FP_SUPPORT_GMP_INT_TYPE 52 enum { result =
true };
59 enum { result =
false };
61 #ifdef FP_SUPPORT_COMPLEX_NUMBERS 63 struct IsComplexType<std::complex<T> >
65 enum { result =
true };
73 template<
typename Value_t>
74 inline Value_t fp_const_pi()
76 return Value_t(3.1415926535897932384626433832795028841971693993751L);
79 template<
typename Value_t>
80 inline Value_t fp_const_e()
82 return Value_t(2.7182818284590452353602874713526624977572L);
84 template<
typename Value_t>
85 inline Value_t fp_const_einv()
87 return Value_t(0.367879441171442321595523770161460867445811131L);
89 template<
typename Value_t>
90 inline Value_t fp_const_log2()
92 return Value_t(0.69314718055994530941723212145817656807550013436025525412L);
94 template<
typename Value_t>
95 inline Value_t fp_const_log10()
97 return Value_t(2.302585092994045684017991454684364207601101488628772976L);
99 template<
typename Value_t>
100 inline Value_t fp_const_log2inv()
102 return Value_t(1.442695040888963407359924681001892137426645954L);
104 template<
typename Value_t>
105 inline Value_t fp_const_log10inv()
107 return Value_t(0.434294481903251827651128918916605082294397L);
110 template<
typename Value_t>
111 inline const Value_t& fp_const_deg_to_rad()
113 static const Value_t factor = fp_const_pi<Value_t>() / Value_t(180);
117 template<
typename Value_t>
118 inline const Value_t& fp_const_rad_to_deg()
120 static const Value_t factor = Value_t(180) / fp_const_pi<Value_t>();
124 #ifdef FP_SUPPORT_MPFR_FLOAT_TYPE 153 template<
typename Value_t>
154 inline Value_t fp_abs(
const Value_t& x) {
return std::fabs(x); }
156 template<
typename Value_t>
157 inline Value_t fp_acos(
const Value_t& x) {
return std::acos(x); }
159 template<
typename Value_t>
160 inline Value_t fp_asin(
const Value_t& x) {
return std::asin(x); }
162 template<
typename Value_t>
163 inline Value_t fp_atan(
const Value_t& x) {
return std::atan(x); }
165 template<
typename Value_t>
166 inline Value_t fp_atan2(
const Value_t& x,
const Value_t& y)
167 {
return std::atan2(x, y); }
169 template<
typename Value_t>
170 inline Value_t fp_ceil(
const Value_t& x) {
return std::ceil(x); }
172 template<
typename Value_t>
173 inline Value_t fp_cos(
const Value_t& x) {
return std::cos(x); }
175 template<
typename Value_t>
176 inline Value_t fp_cosh(
const Value_t& x) {
return std::cosh(x); }
178 template<
typename Value_t>
179 inline Value_t fp_exp(
const Value_t& x) {
return std::exp(x); }
181 template<
typename Value_t>
182 inline Value_t fp_floor(
const Value_t& x) {
return std::floor(x); }
184 template<
typename Value_t>
185 inline Value_t fp_log(
const Value_t& x) {
return std::log(x); }
187 template<
typename Value_t>
188 inline Value_t fp_mod(
const Value_t& x,
const Value_t& y)
189 {
return std::fmod(x, y); }
191 template<
typename Value_t>
192 inline Value_t fp_sin(
const Value_t& x) {
return std::sin(x); }
194 template<
typename Value_t>
195 inline Value_t fp_sinh(
const Value_t& x) {
return std::sinh(x); }
197 template<
typename Value_t>
198 inline Value_t fp_sqrt(
const Value_t& x) {
return std::sqrt(x); }
200 template<
typename Value_t>
201 inline Value_t fp_tan(
const Value_t& x) {
return std::tan(x); }
203 template<
typename Value_t>
204 inline Value_t fp_tanh(
const Value_t& x) {
return std::tanh(x); }
206 #ifdef FP_SUPPORT_CPLUSPLUS11_MATH_FUNCS 207 template<
typename Value_t>
208 inline Value_t fp_asinh(
const Value_t& x) {
return std::asinh(x); }
210 template<
typename Value_t>
211 inline Value_t fp_acosh(
const Value_t& x) {
return std::acosh(x); }
213 template<
typename Value_t>
214 inline Value_t fp_atanh(
const Value_t& x) {
return std::atanh(x); }
216 template<
typename Value_t>
217 inline Value_t fp_asinh(
const Value_t& x)
218 {
return fp_log(x + fp_sqrt(x*x + Value_t(1))); }
220 template<
typename Value_t>
221 inline Value_t fp_acosh(
const Value_t& x)
222 {
return fp_log(x + fp_sqrt(x*x - Value_t(1))); }
224 template<
typename Value_t>
225 inline Value_t fp_atanh(
const Value_t& x)
227 return fp_log( (Value_t(1)+x) / (Value_t(1)-x)) * Value_t(0.5);
232 #endif // FP_SUPPORT_ASINH 234 #ifdef FP_SUPPORT_CPLUSPLUS11_MATH_FUNCS 235 template<
typename Value_t>
236 inline Value_t fp_hypot(
const Value_t& x,
const Value_t& y)
237 {
return std::hypot(x,y); }
239 template<
typename Value_t>
240 inline std::complex<Value_t> fp_hypot
241 (
const std::complex<Value_t>& x,
const std::complex<Value_t>& y)
242 {
return fp_sqrt(x*x + y*y); }
244 template<
typename Value_t>
245 inline Value_t fp_hypot(
const Value_t& x,
const Value_t& y)
246 {
return fp_sqrt(x*x + y*y); }
249 template<
typename Value_t>
250 inline Value_t fp_pow_base(
const Value_t& x,
const Value_t& y)
251 {
return std::pow(x, y); }
253 #ifdef FP_SUPPORT_CPLUSPLUS11_MATH_FUNCS 254 template<
typename Value_t>
255 inline Value_t fp_log2(
const Value_t& x) {
return std::log2(x); }
257 template<
typename Value_t>
258 inline std::complex<Value_t> fp_log2(
const std::complex<Value_t>& x)
260 return fp_log(x) * fp_const_log2inv<Value_t>();
263 template<
typename Value_t>
264 inline Value_t fp_log2(
const Value_t& x)
266 return fp_log(x) * fp_const_log2inv<Value_t>();
268 #endif // FP_SUPPORT_LOG2 270 template<
typename Value_t>
271 inline Value_t fp_log10(
const Value_t& x)
273 return fp_log(x) * fp_const_log10inv<Value_t>();
276 template<
typename Value_t>
277 inline Value_t fp_trunc(
const Value_t& x)
279 return x < Value_t() ? fp_ceil(x) : fp_floor(x);
282 template<
typename Value_t>
283 inline Value_t fp_int(
const Value_t& x)
285 return x < Value_t() ?
286 fp_ceil(x - Value_t(0.5)) : fp_floor(x + Value_t(0.5));
289 template<
typename Value_t>
290 inline void fp_sinCos(Value_t& sinvalue, Value_t& cosvalue,
291 const Value_t& param)
295 cosvalue = fp_cos(param);
296 sinvalue = fp_sin(param);
299 template<
typename Value_t>
300 inline void fp_sinhCosh(Value_t& sinhvalue, Value_t& coshvalue,
301 const Value_t& param)
303 const Value_t ex(fp_exp(param)), emx(fp_exp(-param));
304 sinhvalue = Value_t(0.5)*(ex-emx);
305 coshvalue = Value_t(0.5)*(ex+emx);
308 template<
typename Value_t>
311 static Value_t value;
312 static Value_t defaultValue() {
return 0; }
315 template<>
inline double Epsilon<double>::defaultValue() {
return 1E-12; }
316 template<>
inline float Epsilon<float>::defaultValue() {
return 1E-5F; }
317 template<>
inline long double Epsilon<long double>::defaultValue() {
return 1E-14L; }
319 template<>
inline std::complex<double>
320 Epsilon<std::complex<double> >::defaultValue() {
return 1E-12; }
322 template<>
inline std::complex<float>
323 Epsilon<std::complex<float> >::defaultValue() {
return 1E-5F; }
325 template<>
inline std::complex<long double>
326 Epsilon<std::complex<long double> >::defaultValue() {
return 1E-14L; }
328 #ifdef FP_SUPPORT_MPFR_FLOAT_TYPE 333 template<
typename Value_t> Value_t Epsilon<Value_t>::value =
334 Epsilon<Value_t>::defaultValue();
338 inline void fp_sinCos(
double& sin,
double& cos,
const double& a)
340 sincos(a, &sin, &cos);
342 inline void fp_sinCos(
float& sin,
float& cos,
const float& a)
344 sincosf(a, &sin, &cos);
346 inline void fp_sinCos(
long double& sin,
long double& cos,
347 const long double& a)
349 sincosl(a, &sin, &cos);
357 inline long fp_abs(
const long& x) {
return x < 0 ? -x : x; }
358 inline long fp_acos(
const long&) {
return 0; }
359 inline long fp_asin(
const long&) {
return 0; }
360 inline long fp_atan(
const long&) {
return 0; }
361 inline long fp_atan2(
const long&,
const long&) {
return 0; }
362 inline long fp_cbrt(
const long&) {
return 0; }
363 inline long fp_ceil(
const long& x) {
return x; }
364 inline long fp_cos(
const long&) {
return 0; }
365 inline long fp_cosh(
const long&) {
return 0; }
366 inline long fp_exp(
const long&) {
return 0; }
367 inline long fp_exp2(
const long&) {
return 0; }
368 inline long fp_floor(
const long& x) {
return x; }
369 inline long fp_log(
const long&) {
return 0; }
370 inline long fp_log2(
const long&) {
return 0; }
371 inline long fp_log10(
const long&) {
return 0; }
372 inline long fp_mod(
const long& x,
const long& y) {
return x % y; }
373 inline long fp_pow(
const long&,
const long&) {
return 0; }
374 inline long fp_sin(
const long&) {
return 0; }
375 inline long fp_sinh(
const long&) {
return 0; }
376 inline long fp_sqrt(
const long&) {
return 1; }
377 inline long fp_tan(
const long&) {
return 0; }
378 inline long fp_tanh(
const long&) {
return 0; }
379 inline long fp_asinh(
const long&) {
return 0; }
380 inline long fp_acosh(
const long&) {
return 0; }
381 inline long fp_atanh(
const long&) {
return 0; }
382 inline long fp_pow_base(
const long&,
const long&) {
return 0; }
383 inline void fp_sinCos(
long&,
long&,
const long&) {}
384 inline void fp_sinhCosh(
long&,
long&,
const long&) {}
392 #ifdef FP_SUPPORT_MPFR_FLOAT_TYPE 436 sinhvalue = fp_sinh(paramCopy);
437 coshvalue = fp_cosh(paramCopy);
439 #endif // FP_SUPPORT_MPFR_FLOAT_TYPE 445 #ifdef FP_SUPPORT_GMP_INT_TYPE 477 #endif // FP_SUPPORT_GMP_INT_TYPE 480 #ifdef FP_SUPPORT_CPLUSPLUS11_MATH_FUNCS 481 template<
typename Value_t>
482 inline Value_t fp_cbrt(
const Value_t& x) {
return std::cbrt(x); }
484 template<
typename Value_t>
485 inline Value_t fp_cbrt(
const Value_t& x)
487 return (x > Value_t() ? fp_exp(fp_log( x) / Value_t(3)) :
488 x < Value_t() ? -fp_exp(fp_log(-x) / Value_t(3)) :
497 template<
typename Value_t>
inline Value_t fp_arg(
const Value_t& x);
498 template<
typename Value_t>
inline Value_t fp_exp2(
const Value_t& x);
499 template<
typename Value_t>
inline Value_t fp_int(
const Value_t& x);
500 template<
typename Value_t>
inline Value_t fp_trunc(
const Value_t& x);
501 template<
typename Value_t>
502 inline void fp_sinCos(Value_t& , Value_t& ,
const Value_t& );
503 template<
typename Value_t>
504 inline void fp_sinhCosh(Value_t& , Value_t& ,
const Value_t& );
506 #ifdef FP_SUPPORT_COMPLEX_NUMBERS 516 struct FP_ProbablyHasFastLibcComplex
517 {
enum { result =
false }; };
526 template<>
struct FP_ProbablyHasFastLibcComplex<
float>
527 {
enum { result =
true }; };
528 template<>
struct FP_ProbablyHasFastLibcComplex<double>
529 {
enum { result =
true }; };
530 template<>
struct FP_ProbablyHasFastLibcComplex<long double>
531 {
enum { result =
true }; };
535 inline const std::complex<T> fp_make_imag(
const std::complex<T>& v)
537 return std::complex<T> ( T(), v.real() );
541 inline std::complex<T> fp_real(
const std::complex<T>& x)
546 inline std::complex<T> fp_imag(
const std::complex<T>& x)
551 inline std::complex<T> fp_arg(
const std::complex<T>& x)
556 inline std::complex<T> fp_conj(
const std::complex<T>& x)
560 template<
typename T,
bool>
561 inline std::complex<T> fp_polar(
const T& x,
const T& y)
563 T
si, co; fp_sinCos(si, co, y);
564 return std::complex<T> (x*co, x*si);
567 inline std::complex<T> fp_polar(
const std::complex<T>& x,
const std::complex<T>& y)
570 return fp_polar<T,true> (x.real(), y.real());
577 inline std::complex<T> fp_floor(
const std::complex<T>& x)
579 return std::complex<T> (fp_floor(x.real()), fp_floor(x.imag()));
582 inline std::complex<T> fp_trunc(
const std::complex<T>& x)
584 return std::complex<T> (fp_trunc(x.real()), fp_trunc(x.imag()));
587 inline std::complex<T> fp_int(
const std::complex<T>& x)
589 return std::complex<T> (fp_int(x.real()), fp_int(x.imag()));
592 inline std::complex<T> fp_ceil(
const std::complex<T>& x)
594 return std::complex<T> (fp_ceil(x.real()), fp_ceil(x.imag()));
597 inline std::complex<T> fp_abs(
const std::complex<T>& x)
605 inline std::complex<T> fp_exp(
const std::complex<T>& x)
607 if(FP_ProbablyHasFastLibcComplex<T>::result)
609 return fp_polar<T,true>(fp_exp(x.real()), x.imag());
612 inline std::complex<T> fp_log(
const std::complex<T>& x)
614 if(FP_ProbablyHasFastLibcComplex<T>::result)
619 return std::complex<T>( fp_log(fp_abs(x.real())),
621 return std::complex<T>(
622 fp_log(std::norm(x)) * T(0.5),
626 inline std::complex<T> fp_sqrt(
const std::complex<T>& x)
628 if(FP_ProbablyHasFastLibcComplex<T>::result)
630 return fp_polar<T,true> (fp_sqrt(fp_abs(x).real()),
631 T(0.5)*fp_arg(x).real());
634 inline std::complex<T> fp_acos(
const std::complex<T>& x)
637 const std::complex<T> i (T(), T(1));
638 return -i * fp_log(x + i * fp_sqrt(T(1) - x*x));
643 inline std::complex<T> fp_asin(
const std::complex<T>& x)
646 const std::complex<T> i (T(), T(1));
647 return -i * fp_log(i*x + fp_sqrt(T(1) - x*x));
652 inline std::complex<T> fp_atan(
const std::complex<T>& x)
656 const std::complex<T> i (T(), T(1));
657 return (T(-0.5)*i) * fp_log( (T(1)+i*x) / (T(1)-i*x) );
663 inline std::complex<T> fp_cos(
const std::complex<T>& x)
675 inline std::complex<T> fp_sin(
const std::complex<T>& x)
687 inline void fp_sinCos(
688 std::complex<T>& sinvalue,
689 std::complex<T>& cosvalue,
690 const std::complex<T>& x)
696 T srx, crx; fp_sinCos(srx, crx, x.real());
697 T six, cix; fp_sinhCosh(six, cix, x.imag());
698 sinvalue = std::complex<T>(srx*cix, crx*six);
699 cosvalue = std::complex<T>(crx*cix, -srx*six);
702 inline void fp_sinhCosh(
703 std::complex<T>& sinhvalue,
704 std::complex<T>& coshvalue,
705 const std::complex<T>& x)
707 T srx, crx; fp_sinhCosh(srx, crx, x.real());
708 T six, cix; fp_sinCos(six, cix, x.imag());
709 sinhvalue = std::complex<T>(srx*cix, crx*six);
710 coshvalue = std::complex<T>(crx*cix, srx*six);
713 inline std::complex<T> fp_tan(
const std::complex<T>& x)
726 inline std::complex<T> fp_cosh(
const std::complex<T>& x)
736 inline std::complex<T> fp_sinh(
const std::complex<T>& x)
746 inline std::complex<T> fp_tanh(
const std::complex<T>& x)
758 #ifdef FP_SUPPORT_CPLUSPLUS11_MATH_FUNCS 760 inline std::complex<T> fp_acosh(
const std::complex<T>& x)
761 {
return fp_log(x + fp_sqrt(x*x - std::complex<T>(1))); }
763 inline std::complex<T> fp_asinh(
const std::complex<T>& x)
764 {
return fp_log(x + fp_sqrt(x*x + std::complex<T>(1))); }
766 inline std::complex<T> fp_atanh(
const std::complex<T>& x)
767 {
return fp_log( (std::complex<T>(1)+x) / (std::complex<T>(1)-x))
768 * std::complex<T>(0.5); }
771 inline std::complex<T> fp_pow(
const std::complex<T>& x,
const std::complex<T>& y)
804 const std::complex<T> t =
807 : std::complex<T> (fp_log(fp_abs(x.real())),
809 return y.imag() != T()
811 : fp_polar<T,true> (fp_exp(y.real()*t.real()), y.real()*t.imag());
814 inline std::complex<T> fp_cbrt(
const std::complex<T>& x)
823 if(x.imag() == T())
return fp_cbrt(x.real());
824 const std::complex<T> t(fp_log(x));
825 return fp_polar<T,true> (fp_exp(t.real() / T(3)), t.imag() / T(3));
829 inline std::complex<T> fp_exp2(
const std::complex<T>& x)
833 return fp_polar<T,true> (fp_exp2(x.real()), x.imag()*fp_const_log2<T>());
836 inline std::complex<T> fp_mod(
const std::complex<T>& x,
const std::complex<T>& y)
841 if(y.imag() == 0)
return fp_mod(x.real(), y.real());
842 std::complex<T> n = fp_trunc(x / y);
852 inline std::ostream& operator<<(std::ostream& os, const std::complex<T>& value)
854 if(value.imag() == T())
return os << value.real();
855 if(value.real() == T())
return os << value.imag() <<
'i';
856 if(value.imag() < T())
857 return os <<
'(' << value.real() <<
"-" << -value.imag() <<
"i)";
859 return os <<
'(' << value.real() <<
"+" << value.imag() <<
"i)";
886 inline T fp_complexScalarize(
const std::complex<T>& x)
889 if(x.real() < T()) res = -res;
893 inline T fp_realComplexScalarize(
const T& x)
896 if(x < T()) res = -res;
901 template<typename T> \ 902 inline bool operator op (const std::complex<T>& x, T y) \ 903 { return fp_complexScalarize(x) op fp_realComplexScalarize(y); } \ 904 template<typename T> \ 905 inline bool operator op (const std::complex<T>& x, const std::complex<T>& y) \ 906 { return fp_complexScalarize(x) op \ 907 fp_complexScalarize(y); } \ 908 template<typename T> \ 909 inline bool operator op (T x, const std::complex<T>& y) \ 910 { return fp_realComplexScalarize(x) op fp_complexScalarize(y); } 911 d( < ) d( <= ) d( > ) d( >= )
915 template<
typename Value_t>
916 inline Value_t fp_real(
const Value_t& x) {
return x; }
917 template<
typename Value_t>
918 inline Value_t fp_imag(
const Value_t& ) {
return Value_t(); }
919 template<
typename Value_t>
920 inline Value_t fp_arg(
const Value_t& x)
921 {
return x < Value_t() ? -fp_const_pi<Value_t>() : Value_t(); }
922 template<
typename Value_t>
923 inline Value_t fp_conj(
const Value_t& x) {
return x; }
924 template<
typename Value_t>
925 inline Value_t fp_polar(
const Value_t& x,
const Value_t& y)
926 {
return x * fp_cos(y); }
928 template<
typename Value_t>
929 inline std::complex<Value_t> fp_atan2(
const std::complex<Value_t>& y,
930 const std::complex<Value_t>& x)
932 if(y == Value_t())
return fp_arg(x);
933 if(x == Value_t())
return fp_const_pi<Value_t>() * Value_t(-0.5);
936 std::complex<Value_t> res( fp_atan(y / (fp_hypot(x,y) + x)) );
943 template<
typename Value_t>
944 inline bool fp_equal(
const Value_t& x,
const Value_t& y)
945 {
return IsIntType<Value_t>::result
947 : (fp_abs(x - y) <= Epsilon<Value_t>::value); }
949 template<
typename Value_t>
950 inline bool fp_nequal(
const Value_t& x,
const Value_t& y)
951 {
return IsIntType<Value_t>::result
953 : (fp_abs(x - y) > Epsilon<Value_t>::value); }
955 template<
typename Value_t>
956 inline bool fp_less(
const Value_t& x,
const Value_t& y)
957 {
return IsIntType<Value_t>::result
959 : (x < y - Epsilon<Value_t>::value); }
961 template<
typename Value_t>
962 inline bool fp_lessOrEq(
const Value_t& x,
const Value_t& y)
963 {
return IsIntType<Value_t>::result
965 : (x <= y + Epsilon<Value_t>::value); }
968 template<
typename Value_t>
969 inline bool fp_greater(
const Value_t& x,
const Value_t& y)
970 {
return fp_less(y, x); }
972 template<
typename Value_t>
973 inline bool fp_greaterOrEq(
const Value_t& x,
const Value_t& y)
974 {
return fp_lessOrEq(y, x); }
976 template<
typename Value_t>
977 inline bool fp_truth(
const Value_t& d)
979 return IsIntType<Value_t>::result
981 : fp_abs(d) >= Value_t(0.5);
984 template<
typename Value_t>
985 inline bool fp_absTruth(
const Value_t& abs_d)
987 return IsIntType<Value_t>::result
989 : abs_d >= Value_t(0.5);
992 template<
typename Value_t>
993 inline const Value_t& fp_min(
const Value_t& d1,
const Value_t& d2)
994 {
return d1<d2 ? d1 : d2; }
996 template<
typename Value_t>
997 inline const Value_t& fp_max(
const Value_t& d1,
const Value_t& d2)
998 {
return d1>d2 ? d1 : d2; }
1000 template<
typename Value_t>
1001 inline const Value_t fp_not(
const Value_t& b)
1002 {
return Value_t(!fp_truth(b)); }
1004 template<
typename Value_t>
1005 inline const Value_t fp_notNot(
const Value_t& b)
1006 {
return Value_t(fp_truth(b)); }
1008 template<
typename Value_t>
1009 inline const Value_t fp_absNot(
const Value_t& b)
1010 {
return Value_t(!fp_absTruth(b)); }
1012 template<
typename Value_t>
1013 inline const Value_t fp_absNotNot(
const Value_t& b)
1014 {
return Value_t(fp_absTruth(b)); }
1016 template<
typename Value_t>
1017 inline const Value_t fp_and(
const Value_t& a,
const Value_t& b)
1018 {
return Value_t(fp_truth(a) && fp_truth(b)); }
1020 template<
typename Value_t>
1021 inline const Value_t fp_or(
const Value_t& a,
const Value_t& b)
1022 {
return Value_t(fp_truth(a) || fp_truth(b)); }
1024 template<
typename Value_t>
1025 inline const Value_t fp_absAnd(
const Value_t& a,
const Value_t& b)
1026 {
return Value_t(fp_absTruth(a) && fp_absTruth(b)); }
1028 template<
typename Value_t>
1029 inline const Value_t fp_absOr(
const Value_t& a,
const Value_t& b)
1030 {
return Value_t(fp_absTruth(a) || fp_absTruth(b)); }
1032 template<
typename Value_t>
1033 inline const Value_t fp_make_imag(
const Value_t& )
1043 bool IsLogicalOpcode(
unsigned op);
1044 bool IsComparisonOpcode(
unsigned op);
1045 unsigned OppositeComparisonOpcode(
unsigned op);
1046 bool IsNeverNegativeValueOpcode(
unsigned op);
1047 bool IsAlwaysIntegerOpcode(
unsigned op);
1048 bool IsUnaryOpcode(
unsigned op);
1049 bool IsBinaryOpcode(
unsigned op);
1050 bool IsVarOpcode(
unsigned op);
1051 bool IsCommutativeOrParamSwappableBinaryOpcode(
unsigned op);
1052 unsigned GetParamSwappedBinaryOpcode(
unsigned op);
1054 template<
bool ComplexType>
1055 bool HasInvalidRangesOpcode(
unsigned op);
1057 template<
typename Value_t>
1058 inline Value_t DegreesToRadians(
const Value_t& degrees)
1060 return degrees * fp_const_deg_to_rad<Value_t>();
1063 template<
typename Value_t>
1064 inline Value_t RadiansToDegrees(
const Value_t& radians)
1066 return radians * fp_const_rad_to_deg<Value_t>();
1069 template<
typename Value_t>
1070 inline long makeLongInteger(
const Value_t& value)
1072 return (
long) fp_int(value);
1075 #ifdef FP_SUPPORT_COMPLEX_NUMBERS 1076 template<
typename T>
1077 inline long makeLongInteger(
const std::complex<T>& value)
1079 return (
long) fp_int( std::abs(value) );
1084 template<
typename Value_t>
1085 inline bool isLongInteger(
const Value_t& value)
1087 return value == Value_t( makeLongInteger(value) );
1090 template<
typename Value_t>
1091 inline bool isOddInteger(
const Value_t& value)
1093 const Value_t halfValue = (value + Value_t(1)) * Value_t(0.5);
1094 return fp_equal(halfValue, fp_floor(halfValue));
1097 template<
typename Value_t>
1098 inline bool isEvenInteger(
const Value_t& value)
1100 const Value_t halfValue = value * Value_t(0.5);
1101 return fp_equal(halfValue, fp_floor(halfValue));
1104 template<
typename Value_t>
1105 inline bool isInteger(
const Value_t& value)
1107 return fp_equal(value, fp_floor(value));
1110 #ifdef FP_SUPPORT_LONG_INT_TYPE 1112 inline bool isEvenInteger(
const long& value)
1114 return value%2 == 0;
1118 inline bool isInteger(
const long&) {
return true; }
1121 inline bool isLongInteger(
const long&) {
return true; }
1124 inline long makeLongInteger(
const long& value)
1130 #ifdef FP_SUPPORT_MPFR_FLOAT_TYPE 1135 inline bool isEvenInteger(
const MpfrFloat& value)
1137 return isInteger(value) && value%2 == 0;
1141 inline long makeLongInteger(
const MpfrFloat& value)
1143 return (
long) value.
toInt();
1147 #ifdef FP_SUPPORT_GMP_INT_TYPE 1149 inline bool isEvenInteger(
const GmpInt& value)
1151 return value%2 == 0;
1155 inline bool isInteger(
const GmpInt&) {
return true; }
1158 inline long makeLongInteger(
const GmpInt& value)
1160 return (
long) value.
toInt();
1164 #ifdef FP_SUPPORT_LONG_INT_TYPE 1166 inline bool isOddInteger(
const long& value)
1168 return value%2 != 0;
1172 #ifdef FP_SUPPORT_MPFR_FLOAT_TYPE 1174 inline bool isOddInteger(
const MpfrFloat& value)
1176 return value.
isInteger() && value%2 != 0;
1180 #ifdef FP_SUPPORT_GMP_INT_TYPE 1182 inline bool isOddInteger(
const GmpInt& value)
1184 return value%2 != 0;
1193 template<
typename Value_t>
1194 inline Value_t fp_pow_with_exp_log(
const Value_t& x,
const Value_t& y)
1196 return fp_exp(fp_log(x) * y);
1199 template<
typename Value_t>
1200 inline Value_t fp_powi(Value_t x,
unsigned long y)
1205 if(y & 1) { result *= x; y -= 1; }
1206 else { x *= x; y /= 2; }
1211 template<
typename Value_t>
1212 Value_t fp_pow(
const Value_t& x,
const Value_t& y)
1214 if(x == Value_t(1))
return Value_t(1);
1215 if(isLongInteger(y))
1218 return fp_powi(x, makeLongInteger(y));
1220 return Value_t(1) / fp_powi(x, -makeLongInteger(y));
1224 if(x > Value_t(0))
return fp_pow_with_exp_log(x, y);
1225 if(x == Value_t(0))
return Value_t(0);
1226 if(!isInteger(y*Value_t(16)))
1227 return -fp_pow_with_exp_log(-x, y);
1231 if(x > Value_t(0))
return fp_pow_with_exp_log(Value_t(1) / x, -y);
1234 if(!isInteger(y*Value_t(-16)))
1235 return -fp_pow_with_exp_log(Value_t(-1) / x, -y);
1238 return fp_pow_base(x, y);
1241 template<
typename Value_t>
1242 inline Value_t fp_exp2(
const Value_t& x)
1244 return fp_pow(Value_t(2), x);
1248 #endif // ONCE_FPARSER_H_ 1249 #endif // ONCE_FPARSER_AUX_H_ static MpfrFloat sqrt(const MpfrFloat &)
static MpfrFloat cbrt(const MpfrFloat &)
static MpfrFloat tan(const MpfrFloat &)
static MpfrFloat const_log2()
static MpfrFloat log(const MpfrFloat &)
static MpfrFloat pow(const MpfrFloat &, const MpfrFloat &)
static MpfrFloat asinh(const MpfrFloat &)
static MpfrFloat round(const MpfrFloat &)
static MpfrFloat sin(const MpfrFloat &)
static MpfrFloat trunc(const MpfrFloat &)
static MpfrFloat acos(const MpfrFloat &)
static MpfrFloat atan(const MpfrFloat &)
static MpfrFloat atan2(const MpfrFloat &, const MpfrFloat &)
static void sincos(const MpfrFloat &, MpfrFloat &sin, MpfrFloat &cos)
static MpfrFloat const_pi()
static MpfrFloat asin(const MpfrFloat &)
static MpfrFloat sinh(const MpfrFloat &)
static MpfrFloat tanh(const MpfrFloat &)
static MpfrFloat cos(const MpfrFloat &)
static MpfrFloat cosh(const MpfrFloat &)
static MpfrFloat hypot(const MpfrFloat &, const MpfrFloat &)
static MpfrFloat log10(const MpfrFloat &)
static MpfrFloat exp2(const MpfrFloat &)
static MpfrFloat atanh(const MpfrFloat &)
static MpfrFloat acosh(const MpfrFloat &)
static MpfrFloat const_e()
static MpfrFloat log2(const MpfrFloat &)
static MpfrFloat ceil(const MpfrFloat &)
static MpfrFloat someEpsilon()
static MpfrFloat floor(const MpfrFloat &)
static MpfrFloat exp(const MpfrFloat &)