fwd.hpp

//
// Copyright (c) 2016-2024 CNRS INRIA
//

#ifndef __pinocchio_math_fwd_hpp__
#define __pinocchio_math_fwd_hpp__

#include "pinocchio/fwd.hpp"
#include <math.h>
#include <boost/math/constants/constants.hpp>
#include <boost/type_traits/is_floating_point.hpp>

namespace pinocchio
{

 template<typename T>
 struct is_floating_point : boost::is_floating_point<T>
 {
 };

 template<typename Scalar>
 const Scalar PI()
 {
 return boost::math::constants::pi<Scalar>();
 }

 template<typename Scalar>
 struct TaylorSeriesExpansion;

 namespace math
 {

#define PINOCCHIO_OVERLOAD_MATH_UNARY_OPERATOR(name) \
 template<typename Scalar> \
 Scalar name(const Scalar & value) \
 { \
 using std::name; \
 return name(value); \
 }

#define PINOCCHIO_OVERLOAD_MATH_BINARY_OPERATOR(name) \
 namespace internal \
 { \
 template<typename T1, typename T2> \
 struct return_type_##name \
 { \
 typedef T1 type; \
 }; \
 template<typename T1, typename T2> \
 struct call_##name \
 { \
 static inline typename return_type_##name<T1, T2>::type run(const T1 & a, const T2 & b) \
 { \
 using std::name; \
 return name(a, b); \
 } \
 }; \
 } \
 template<typename T1, typename T2> \
 inline typename internal::return_type_##name<T1, T2>::type name(const T1 & a, const T2 & b) \
 { \
 return internal::call_##name<T1, T2>::run(a, b); \
 }

 PINOCCHIO_OVERLOAD_MATH_UNARY_OPERATOR(fabs)
 PINOCCHIO_OVERLOAD_MATH_UNARY_OPERATOR(sqrt)
 PINOCCHIO_OVERLOAD_MATH_UNARY_OPERATOR(atan)
 PINOCCHIO_OVERLOAD_MATH_UNARY_OPERATOR(acos)
 PINOCCHIO_OVERLOAD_MATH_UNARY_OPERATOR(asin)
 PINOCCHIO_OVERLOAD_MATH_UNARY_OPERATOR(cos)
 PINOCCHIO_OVERLOAD_MATH_UNARY_OPERATOR(sin)
 PINOCCHIO_OVERLOAD_MATH_UNARY_OPERATOR(log)
 PINOCCHIO_OVERLOAD_MATH_UNARY_OPERATOR(exp)

 PINOCCHIO_OVERLOAD_MATH_BINARY_OPERATOR(pow)
 PINOCCHIO_OVERLOAD_MATH_BINARY_OPERATOR(min)
 PINOCCHIO_OVERLOAD_MATH_BINARY_OPERATOR(max)
 PINOCCHIO_OVERLOAD_MATH_BINARY_OPERATOR(atan2)
 } // namespace math
} // namespace pinocchio

#endif // #ifndef __pinocchio_math_fwd_hpp__