mirror/Sprout
1
0
Fork 0
mirror of https://github.com/bolero-MURAKAMI/Sprout.git synced 2025-01-23 20:46:37 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

add quaternion adapt (hash, tuple)

Browse source
This commit is contained in:
bolero-MURAKAMI 2016-02-27 01:21:46 +09:00
parent 35bd69d5d3
commit 37eea2c53d
35 changed files with 1941 additions and 974 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
sprout/complex/container.hpp
View file

@ -8,7 +8,7 @@
#ifndef SPROUT_COMPLEX_CONTAINER_HPP
#define SPROUT_COMPLEX_CONTAINER_HPP
#include <type_traits>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/complex/complex.hpp>
#include <sprout/container/traits.hpp>

8
sprout/math/quaternion.hpp
View file

@ -10,6 +10,14 @@
#include <sprout/config.hpp>
#include <sprout/math/quaternion/quaternion.hpp>
#include <sprout/math/quaternion/operators.hpp>
#include <sprout/math/quaternion/values.hpp>
#include <sprout/math/quaternion/creations.hpp>
#include <sprout/math/quaternion/transcendentals.hpp>
#include <sprout/math/quaternion/hash.hpp>
#include <sprout/math/quaternion/tuple.hpp>
#include <sprout/math/quaternion/container.hpp>
#include <sprout/math/quaternion/udl.hpp>
#include <sprout/math/quaternion/type_traits.hpp>
#endif // #ifndef SPROUT_MATH_QUATERNION_HPP

71
sprout/math/quaternion/abs.hpp Normal file
View file

@ -0,0 +1,71 @@
/*=============================================================================
Copyright (c) 2011-2016 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_MATH_QUATERNION_ABS_HPP
#define SPROUT_MATH_QUATERNION_ABS_HPP
#include <sprout/config.hpp>
#include <sprout/array/array.hpp>
#include <sprout/math/sqrt.hpp>
#include <sprout/math/quaternion/quaternion.hpp>
#include <sprout/math/quaternion/detail/abs_max.hpp>
#include <sprout/math/quaternion/detail/sum.hpp>
#include <sprout/math/quaternion/detail/mul.hpp>
namespace sprout {
namespace math {
//
// abs
//
namespace detail {
template<typename T>
inline SPROUT_CONSTEXPR T
abs_q_impl_3(sprout::array<T, 4> const& temp, T const& maxim) {
return maxim * sprout::math::sqrt(sprout::math::detail::sum(sprout::math::detail::mul(temp, temp)));
}
template<typename T>
inline SPROUT_CONSTEXPR T
abs_q_impl_2(sprout::array<T, 4> const& temp, T const& maxim) {
return sprout::math::detail::abs_q_impl_3(
sprout::math::detail::mul(temp, maxim), maxim
);
}
template<typename T>
inline SPROUT_CONSTEXPR T
abs_q_impl_1(sprout::array<T, 4> const& temp, T const& maxim) {
return maxim == static_cast<T>(0) ? sprout::math::quaternion<T>(maxim)
: sprout::math::detail::abs_q_impl_2(
temp, static_cast<T>(1) / maxim
)
;
}
template<typename T>
inline SPROUT_CONSTEXPR T
abs_q_impl(sprout::array<T, 4> const& temp) {
return sprout::math::detail::abs_q_impl_1(
temp, sprout::math::detail::abs_max(temp)
);
}
} // namespace detail
template<typename T>
inline SPROUT_CONSTEXPR T
abs(sprout::math::quaternion<T> const& q) {
return sprout::math::detail::abs_q_impl(
sprout::array<T, 4>{{
q.R_component_1(),
q.R_component_2(),
q.R_component_3(),
q.R_component_4()
}}
);
}
} // namespace math
using sprout::math::abs;
} // namespace sprout
#endif // #ifndef SPROUT_MATH_QUATERNION_ABS_HPP

34
sprout/math/quaternion/conj.hpp Normal file
View file

@ -0,0 +1,34 @@
/*=============================================================================
Copyright (c) 2011-2016 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_MATH_QUATERNION_CONJ_HPP
#define SPROUT_MATH_QUATERNION_CONJ_HPP
#include <sprout/config.hpp>
#include <sprout/math/quaternion/quaternion.hpp>
namespace sprout {
namespace math {
//
// conj
//
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
conj(sprout::math::quaternion<T> const& q) {
return sprout::math::quaternion<T>(
+q.R_component_1(),
-q.R_component_2(),
-q.R_component_3(),
-q.R_component_4()
);
}
} // namespace math
using sprout::math::conj;
} // namespace sprout
#endif // #ifndef SPROUT_MATH_QUATERNION_CONJ_HPP

8
sprout/math/quaternion/container.hpp
View file

@ -5,10 +5,10 @@
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_QUATERNION_CONTAINER_HPP
#define SPROUT_QUATERNION_CONTAINER_HPP
#ifndef SPROUT_MATH_QUATERNION_CONTAINER_HPP
#define SPROUT_MATH_QUATERNION_CONTAINER_HPP
#include <type_traits>
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/math/quaternion/quaternion.hpp>
#include <sprout/container/traits.hpp>
@ -40,4 +40,4 @@ namespace sprout {
};
} // namespace sprout
#endif // #ifndef SPROUT_QUATERNION_CONTAINER_HPP
#endif // #ifndef SPROUT_MATH_QUATERNION_CONTAINER_HPP

60
sprout/math/quaternion/cos.hpp Normal file
View file

@ -0,0 +1,60 @@
/*=============================================================================
Copyright (c) 2011-2016 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_MATH_QUATERNION_COS_HPP
#define SPROUT_MATH_QUATERNION_COS_HPP
#include <sprout/config.hpp>
#include <sprout/math/cos.hpp>
#include <sprout/math/sin.hpp>
#include <sprout/math/cosh.hpp>
//#include <sprout/math/sinhc.hpp>
#include <sprout/math/quaternion/quaternion.hpp>
#include <sprout/math/quaternion/real.hpp>
#include <sprout/math/quaternion/unreal.hpp>
#include <sprout/math/quaternion/abs.hpp>
namespace sprout {
namespace math {
//
// cos
//
// !!!
// namespace detail {
// template<typename T>
// inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
// cos_impl_1(sprout::math::quaternion<T> const& q, T const& z, T const& w) {
// return sprout::math::quaternion<T>(
// sprout::math::cos(sprout::math::real(q)) * sprout::math::cosh(z),
// w * q.R_component_2(),
// w * q.R_component_3(),
// w * q.R_component_4()
// );
// }
// template<typename T>
// inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
// cos_impl(sprout::math::quaternion<T> const& q, T const& z) {
// return sprout::math::detail::cos_impl_1(
// q, z,
// -sprout::math::sin(sprout::math::real(q)) * sprout::math::sinhc_pi(z)
// );
// }
// } // namespace detail
// template<typename T>
// inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
// cos(sprout::math::quaternion<T> const& q) {
// return sprout::math::detail::cos_impl(
// q,
// sprout::math::abs(sprout::math::unreal(q))
// );
// }
} // namespace math
// using sprout::math::cos;
} // namespace sprout
#endif // #ifndef SPROUT_MATH_QUATERNION_COS_HPP

31
sprout/math/quaternion/cosh.hpp Normal file
View file

@ -0,0 +1,31 @@
/*=============================================================================
Copyright (c) 2011-2016 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_MATH_QUATERNION_COSH_HPP
#define SPROUT_MATH_QUATERNION_COSH_HPP
#include <sprout/config.hpp>
#include <sprout/math/quaternion/quaternion.hpp>
#include <sprout/math/quaternion/exp.hpp>
namespace sprout {
namespace math {
//
// cosh
//
// !!!
// template<typename T>
// inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
// cosh(sprout::math::quaternion<T> const& q) {
// return (sprout::math::exp(+q) + sprout::math::exp(-q)) / static_cast<T>(2);
// }
} // namespace math
// using sprout::math::cosh;
} // namespace sprout
#endif // #ifndef SPROUT_MATH_QUATERNION_COSH_HPP

18
sprout/math/quaternion/creations.hpp Normal file
View file

@ -0,0 +1,18 @@
/*=============================================================================
Copyright (c) 2011-2016 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_MATH_QUATERNION_CREATIONS_HPP
#define SPROUT_MATH_QUATERNION_CREATIONS_HPP
#include <sprout/config.hpp>
#include <sprout/math/quaternion/spherical.hpp>
#include <sprout/math/quaternion/semipolar.hpp>
#include <sprout/math/quaternion/multipolar.hpp>
#include <sprout/math/quaternion/cylindrospherical.hpp>
#include <sprout/math/quaternion/cylindrical.hpp>
#endif // #ifndef SPROUT_MATH_QUATERNION_CREATIONS_HPP

36
sprout/math/quaternion/cylindrical.hpp Normal file
View file

@ -0,0 +1,36 @@
/*=============================================================================
Copyright (c) 2011-2016 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_MATH_QUATERNION_CYLINDRICAL_HPP
#define SPROUT_MATH_QUATERNION_CYLINDRICAL_HPP
#include <sprout/config.hpp>
#include <sprout/math/cos.hpp>
#include <sprout/math/sin.hpp>
#include <sprout/math/quaternion/quaternion.hpp>
namespace sprout {
namespace math {
//
// cylindrical
//
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
cylindrical(T const& r, T const& angle, T const& h1, T const& h2) {
return sprout::math::quaternion<T>(
r * sprout::math::cos(angle),
r * sprout::math::sin(angle),
h1,
h2
);
}
} // namespace math
using sprout::math::cylindrical;
} // namespace sprout
#endif // #ifndef SPROUT_MATH_QUATERNION_CYLINDRICAL_HPP

36
sprout/math/quaternion/cylindrospherical.hpp Normal file
View file

@ -0,0 +1,36 @@
/*=============================================================================
Copyright (c) 2011-2016 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_MATH_QUATERNION_CYLINDROSPERICAL_HPP
#define SPROUT_MATH_QUATERNION_CYLINDROSPERICAL_HPP
#include <sprout/config.hpp>
#include <sprout/math/cos.hpp>
#include <sprout/math/sin.hpp>
#include <sprout/math/quaternion/quaternion.hpp>
namespace sprout {
namespace math {
//
// cylindrospherical
//
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
cylindrospherical(T const& t, T const& radius, T const& longitude, T const& latitude) {
return sprout::math::quaternion<T>(
t,
radius * sprout::math::cos(longitude) * sprout::math::cos(latitude),
radius * sprout::math::sin(longitude) * sprout::math::cos(latitude),
radius * sprout::math::sin(latitude)
);
}
} // namespace math
using sprout::math::cylindrospherical;
} // namespace sprout
#endif // #ifndef SPROUT_MATH_QUATERNION_CYLINDROSPERICAL_HPP

38
sprout/math/quaternion/detail/abs_max.hpp Normal file
View file

@ -0,0 +1,38 @@
/*=============================================================================
Copyright (c) 2011-2016 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_MATH_QUATERNION_DETAIL_ABS_MAX_HPP
#define SPROUT_MATH_QUATERNION_DETAIL_ABS_MAX_HPP
#include <sprout/config.hpp>
#include <sprout/workaround/std/cstddef.hpp>
#include <sprout/array/array.hpp>
#include <sprout/math/abs.hpp>
#include <sprout/range/algorithm/max_element.hpp>
namespace sprout {
namespace math {
namespace detail {
template<typename T>
class abs_less {
public:
SPROUT_CONSTEXPR T
operator()(T const& lhs, T const& rhs) const {
return sprout::math::abs(lhs) < sprout::math::abs(rhs);
}
};
template<typename T, std::size_t N>
SPROUT_CONSTEXPR T
abs_max(sprout::array<T, N> const& c) {
return sprout::math::abs(*sprout::range::max_element(c, sprout::math::detail::abs_less<T>()));
}
} // namespace detail
} // namespace math
} // namespace sprout
#endif // #ifndef SPROUT_MATH_QUATERNION_DETAIL_ABS_MAX_HPP

57
sprout/math/quaternion/detail/mul.hpp Normal file
View file

@ -0,0 +1,57 @@
/*=============================================================================
Copyright (c) 2011-2016 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_MATH_QUATERNION_DETAIL_MUL_HPP
#define SPROUT_MATH_QUATERNION_DETAIL_MUL_HPP
#include <sprout/config.hpp>
#include <sprout/array/array.hpp>
namespace sprout {
namespace math {
namespace detail {
template<typename T>
SPROUT_CONSTEXPR sprout::array<T, 2>
mul(sprout::array<T, 2> const& l, T const& r) {
return sprout::array<T, 2>{{
l[0] * r,
l[1] * r,
}};
}
template<typename T>
SPROUT_CONSTEXPR sprout::array<T, 2>
mul(sprout::array<T, 2> const& l, sprout::array<T, 2> const& r) {
return sprout::array<T, 2>{{
l[0] * r[0],
l[1] * r[1],
}};
}
template<typename T>
SPROUT_CONSTEXPR sprout::array<T, 4>
mul(sprout::array<T, 4> const& l, T const& r) {
return sprout::array<T, 4>{{
l[0] * r,
l[1] * r,
l[2] * r,
l[3] * r
}};
}
template<typename T>
SPROUT_CONSTEXPR sprout::array<T, 4>
mul(sprout::array<T, 4> const& l, sprout::array<T, 4> const& r) {
return sprout::array<T, 4>{{
l[0] * r[0],
l[1] * r[1],
l[2] * r[2],
l[3] * r[3]
}};
}
} // namespace detail
} // namespace math
} // namespace sprout
#endif // #ifndef SPROUT_MATH_QUATERNION_DETAIL_MUL_HPP

43
sprout/math/quaternion/detail/sum.hpp Normal file
View file

@ -0,0 +1,43 @@
/*=============================================================================
Copyright (c) 2011-2016 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_MATH_QUATERNION_DETAIL_SUM_HPP
#define SPROUT_MATH_QUATERNION_DETAIL_SUM_HPP
#include <sprout/config.hpp>
#include <sprout/workaround/std/cstddef.hpp>
#include <sprout/array/array.hpp>
#include <sprout/math/abs.hpp>
#include <sprout/range/numeric/accumulate.hpp>
namespace sprout {
namespace math {
namespace detail {
template<typename T>
class abs_plus {
public:
SPROUT_CONSTEXPR T
operator()(T const& lhs, T const& rhs) const {
return sprout::math::abs(lhs) + sprout::math::abs(rhs);
}
};
template<typename T, std::size_t N>
SPROUT_CONSTEXPR T
sum(sprout::array<T, N> const& c) {
return sprout::range::accumulate(c, static_cast<T>(0));
}
template<typename T, std::size_t N>
SPROUT_CONSTEXPR T
abs_sum(sprout::array<T, N> const& c) {
return sprout::range::accumulate(c, static_cast<T>(0), sprout::math::detail::abs_plus<T>());
}
} // namespace detail
} // namespace math
} // namespace sprout
#endif // #ifndef SPROUT_MATH_QUATERNION_DETAIL_SUM_HPP

58
sprout/math/quaternion/exp.hpp Normal file
View file

@ -0,0 +1,58 @@
/*=============================================================================
Copyright (c) 2011-2016 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_MATH_QUATERNION_EXP_HPP
#define SPROUT_MATH_QUATERNION_EXP_HPP
#include <sprout/config.hpp>
#include <sprout/math/cos.hpp>
#include <sprout/math/exp.hpp>
//#include <sprout/math/sinc.hpp>
#include <sprout/math/quaternion/quaternion.hpp>
#include <sprout/math/quaternion/real.hpp>
#include <sprout/math/quaternion/unreal.hpp>
#include <sprout/math/quaternion/abs.hpp>
namespace sprout {
namespace math {
//
// exp
//
// !!!
// namespace detail {
// template<typename T>
// inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
// exp_impl_1(sprout::math::quaternion<T> const& q, T const& z, T const& w) {
// return sprout::math::exp(sprout::math::real(q)) * sprout::math::quaternion<T>(
// sprout::math::cos(z),
// w * q.R_component_2(),
// w * q.R_component_3(),
// w * q.R_component_4()
// );
// }
// template<typename T>
// inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
// exp_impl(sprout::math::quaternion<T> const& q, T const& z) {
// return sprout::math::detail::exp_impl_1(
// q, z,
// sprout::math::sinc_pi(z)
// );
// }
// } // namespace detail
// inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
// exp(sprout::math::quaternion<T> const& q) {
// return sprout::math::detail::exp_impl(
// q,
// sprout::math::abs(sprout::math::unreal(q))
// );
// }
} // namespace math
// using sprout::math::exp;
} // namespace sprout
#endif // #ifndef SPROUT_MATH_QUATERNION_EXP_HPP

45
sprout/math/quaternion/hash.hpp Normal file
View file

@ -0,0 +1,45 @@
/*=============================================================================
Copyright (c) 2011-2016 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_MATH_QUATERNION_HASH_HPP
#define SPROUT_MATH_QUATERNION_HASH_HPP
#include <functional>
#include <sprout/config.hpp>
#include <sprout/workaround/std/cstddef.hpp>
#include <sprout/math/quaternion/quaternion.hpp>
#include <sprout/functional/hash.hpp>
namespace sprout {
//
// hash_value
//
template<typename T>
inline SPROUT_CONSTEXPR std::size_t
hash_value(sprout::math::quaternion<T> const& v) {
return sprout::hash_values(v[0], v[1], v[2], v[3]);
}
} // namespace sprout
namespace std {
#if defined(__clang__)
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Wmismatched-tags"
#endif
//
// hash
//
template<typename T>
struct hash<sprout::math::quaternion<T> >
: public sprout::hash<sprout::math::quaternion<T> >
{};
#if defined(__clang__)
# pragma clang diagnostic pop
#endif
} // namespace std
#endif // #ifndef SPROUT_MATH_QUATERNION_HASH_HPP

38
sprout/math/quaternion/l1.hpp Normal file
View file

@ -0,0 +1,38 @@
/*=============================================================================
Copyright (c) 2011-2016 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_MATH_QUATERNION_SUP_HPP
#define SPROUT_MATH_QUATERNION_SUP_HPP
#include <sprout/config.hpp>
#include <sprout/array/array.hpp>
#include <sprout/math/quaternion/quaternion.hpp>
#include <sprout/math/quaternion/detail/sum.hpp>
namespace sprout {
namespace math {
//
// l1
//
template<typename T>
inline SPROUT_CONSTEXPR T
l1(sprout::math::quaternion<T> const& q) {
return sprout::math::detail::abs_sum(
sprout::array<T, 4>{{
q.R_component_1(),
q.R_component_2(),
q.R_component_3(),
q.R_component_4()
}}
);
}
} // namespace math
using sprout::math::l1;
} // namespace sprout
#endif // #ifndef SPROUT_MATH_QUATERNION_SUP_HPP

36
sprout/math/quaternion/multipolar.hpp Normal file
View file

@ -0,0 +1,36 @@
/*=============================================================================
Copyright (c) 2011-2016 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_MATH_QUATERNION_MULTIPOLAR_HPP
#define SPROUT_MATH_QUATERNION_MULTIPOLAR_HPP
#include <sprout/config.hpp>
#include <sprout/math/cos.hpp>
#include <sprout/math/sin.hpp>
#include <sprout/math/quaternion/quaternion.hpp>
namespace sprout {
namespace math {
//
// multipolar
//
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
multipolar(T const& rho1, T const& theta1, T const& rho2, T const& theta2) {
return sprout::math::quaternion<T>(
rho1 * sprout::math::cos(theta1),
rho1 * sprout::math::sin(theta1),
rho2 * sprout::math::cos(theta2),
rho2 * sprout::math::sin(theta2)
);
}
} // namespace math
using sprout::math::multipolar;
} // namespace sprout
#endif // #ifndef SPROUT_MATH_QUATERNION_MULTIPOLAR_HPP

32
sprout/math/quaternion/norm.hpp Normal file
View file

@ -0,0 +1,32 @@
/*=============================================================================
Copyright (c) 2011-2016 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_MATH_QUATERNION_NORM_HPP
#define SPROUT_MATH_QUATERNION_NORM_HPP
#include <sprout/config.hpp>
#include <sprout/math/quaternion/quaternion.hpp>
#include <sprout/math/quaternion/operators.hpp>
#include <sprout/math/quaternion/real.hpp>
#include <sprout/math/quaternion/conj.hpp>
namespace sprout {
namespace math {
//
// norm
//
template<typename T>
inline SPROUT_CONSTEXPR T
norm(sprout::math::quaternion<T> const& q) {
return sprout::math::real(q * sprout::math::conj(q));
}
} // namespace math
using sprout::math::norm;
} // namespace sprout
#endif // #ifndef SPROUT_MATH_QUATERNION_NORM_HPP

562
sprout/math/quaternion/operators.hpp Normal file
View file

@ -0,0 +1,562 @@
/*=============================================================================
Copyright (c) 2011-2016 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_MATH_QUATERNION_OPERATORS_HPP
#define SPROUT_MATH_QUATERNION_OPERATORS_HPP
#include <iosfwd>
#include <sstream>
#include <locale>
#include <sprout/config.hpp>
#include <sprout/math/quaternion/quaternion.hpp>
namespace sprout {
namespace math {
//
// operator+
//
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator+(T const& lhs, sprout::math::quaternion<T> const& rhs) {
return sprout::math::quaternion<T>(
lhs + rhs.R_component_1(),
rhs.R_component_2(),
rhs.R_component_3(),
rhs.R_component_4()
);
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator+(sprout::math::quaternion<T> const& lhs, T const& rhs) {
return sprout::math::quaternion<T>(
lhs.R_component_1() + rhs,
lhs.R_component_2(),
lhs.R_component_3(),
lhs.R_component_4()
);
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator+(sprout::complex<T> const& lhs, sprout::math::quaternion<T> const& rhs) {
return sprout::math::quaternion<T>(
lhs.real() + rhs.R_component_1(),
lhs.imag() + rhs.R_component_2(),
rhs.R_component_3(),
rhs.R_component_4()
);
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator+(sprout::math::quaternion<T> const& lhs, sprout::complex<T> const& rhs) {
return sprout::math::quaternion<T>(
lhs.R_component_1() + rhs.real(),
lhs.R_component_2() + rhs.imag(),
lhs.R_component_3(),
lhs.R_component_4()
);
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator+(sprout::math::quaternion<T> const& lhs, sprout::math::quaternion<T> const& rhs) {
return sprout::math::quaternion<T>(
lhs.R_component_1() + rhs.R_component_1(),
lhs.R_component_2() + rhs.R_component_2(),
lhs.R_component_3() + rhs.R_component_3(),
lhs.R_component_4() + rhs.R_component_4()
);
}
//
// operator-
//
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator-(T const& lhs, sprout::math::quaternion<T> const& rhs) {
return sprout::math::quaternion<T>(
lhs - rhs.R_component_1(),
rhs.R_component_2(),
rhs.R_component_3(),
rhs.R_component_4()
);
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator-(sprout::math::quaternion<T> const& lhs, T const& rhs) {
return sprout::math::quaternion<T>(
lhs.R_component_1() - rhs,
lhs.R_component_2(),
lhs.R_component_3(),
lhs.R_component_4()
);
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator-(sprout::complex<T> const& lhs, sprout::math::quaternion<T> const& rhs) {
return sprout::math::quaternion<T>(
lhs.real() - rhs.R_component_1(),
lhs.imag() - rhs.R_component_2(),
rhs.R_component_3(),
rhs.R_component_4()
);
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator-(sprout::math::quaternion<T> const& lhs, sprout::complex<T> const& rhs) {
return sprout::math::quaternion<T>(
lhs.R_component_1() - rhs.real(),
lhs.R_component_2() - rhs.imag(),
lhs.R_component_3(),
lhs.R_component_4()
);
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator-(sprout::math::quaternion<T> const& lhs, sprout::math::quaternion<T> const& rhs) {
return sprout::math::quaternion<T>(
lhs.R_component_1() - rhs.R_component_1(),
lhs.R_component_2() - rhs.R_component_2(),
lhs.R_component_3() - rhs.R_component_3(),
lhs.R_component_4() - rhs.R_component_4()
);
}
//
// operator*
//
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator*(T const& lhs, sprout::math::quaternion<T> const& rhs) {
return sprout::math::quaternion<T>(
lhs * rhs.R_component_1(),
lhs * rhs.R_component_2(),
lhs * rhs.R_component_3(),
lhs * rhs.R_component_4()
);
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator*(sprout::math::quaternion<T> const& lhs, T const& rhs) {
return sprout::math::quaternion<T>(
lhs.R_component_1() * rhs,
lhs.R_component_2() * rhs,
lhs.R_component_3() * rhs,
lhs.R_component_4() * rhs
);
}
namespace detail {
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
mul_qc_impl(T const& a, T const& b, T const& c, T const& d, T const& ar, T const& br) {
return sprout::math::quaternion<T>(
+a * ar - b * br,
+a * br + b * ar,
+c * ar + d * br,
-c * br + d * ar
);
}
} // namespace detail
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator*(sprout::complex<T> const& lhs, sprout::math::quaternion<T> const& rhs) {
return sprout::math::detail::mul_qc_impl(
lhs.R_component_1(), lhs.R_component_2(), lhs.R_component_3(), lhs.R_component_4(),
rhs.real(), rhs.imag()
);
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator*(sprout::math::quaternion<T> const& lhs, sprout::complex<T> const& rhs) {
return sprout::math::detail::mul_qc_impl(
rhs.R_component_1(), rhs.R_component_2(), rhs.R_component_3(), rhs.R_component_4(),
lhs.real(), lhs.imag()
);
}
namespace detail {
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
mul_qq_impl(T const& a, T const& b, T const& c, T const& d, T const& ar, T const& br, T const& cr, T const& dr) {
return sprout::math::quaternion<T>(
+a * ar - b * br - c * cr - d * dr,
+a * br + b * ar + c * dr - d * cr,
+a * cr - b * dr + c * ar + d * br,
+a * dr + b * cr - c * br + d * ar
);
}
} // namespace detail
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator*(sprout::math::quaternion<T> const& lhs, sprout::math::quaternion<T> const& rhs) {
return sprout::math::detail::mul_qq_impl(
lhs.R_component_1(), lhs.R_component_2(), lhs.R_component_3(), lhs.R_component_4(),
rhs.R_component_1(), rhs.R_component_2(), rhs.R_component_3(), rhs.R_component_4()
);
}
//
// operator/
//
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator/(T const& lhs, sprout::math::quaternion<T> const& rhs) {
return sprout::math::quaternion<T>(
lhs / rhs.R_component_1(),
lhs / rhs.R_component_2(),
lhs / rhs.R_component_3(),
lhs / rhs.R_component_4()
);
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator/(sprout::math::quaternion<T> const& lhs, T const& rhs) {
return sprout::math::quaternion<T>(
lhs.R_component_1() / rhs,
lhs.R_component_2() / rhs,
lhs.R_component_3() / rhs,
lhs.R_component_4() / rhs
);
}
namespace detail {
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
div_qq_impl_4(sprout::array<T, 4> const& tt) {
return sprout::math::quaternion<T>(
tt[0], tt[1], tt[2], tt[3]
);
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
div_qq_impl_3(sprout::array<T, 4> const& tr, T const& mixam, sprout::array<T, 4> const& tt) {
return sprout::math::detail::div_qq_impl_3(
sprout::math::detail::mul(tt, mixam / sprout::math::detail::sum(tr))
);
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
div_qq_impl_2(T const& a, T const& b, T const& c, T const& d, sprout::array<T, 4> const& tr, T const& mixam) {
return sprout::math::detail::div_qq_impl_3(
sprout::math::detail::mul(tr, tr), mixam,
sprout::array<T, 4>{{
+a * tr[0] + b * tr[1] + c * tr[2] + d * tr[3],
-a * tr[1] + b * tr[0] - c * tr[3] + d * tr[2],
-a * tr[2] + b * tr[3] + c * tr[0] - d * tr[1],
-a * tr[3] - b * tr[2] + c * tr[1] + d * tr[0]
}}
);
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
div_qq_impl_1(T const& a, T const& b, T const& c, T const& d, sprout::array<T, 4> const& tr, T const& mixam) {
return sprout::math::detail::div_qq_impl_2(
a, b, c, d, sprout::math::detail::mul(tr, mixam), mixam
);
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
div_qq_impl(T const& a, T const& b, T const& c, T const& d, sprout::array<T, 4> const& tr) {
return sprout::math::detail::div_qq_impl_1(
a, b, c, d, tr,
static_cast<T>(1) / sprout::math::detail::abs_max(tr)
);
}
} // namespace detail
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator/(sprout::complex<T> const& lhs, sprout::math::quaternion<T> const& rhs) {
return sprout::math::detail::div_qq_impl(
lhs.real(), lhs.imag(), static_cast<T>(0), static_cast<T>(0),
sprout::array<T, 4>{{rhs.R_component_1(), rhs.R_component_2(), rhs.R_component_3(), rhs.R_component_4()}}
);
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator/(sprout::math::quaternion<T> const& lhs, sprout::complex<T> const& rhs) {
return sprout::math::detail::div_qq_impl(
lhs.R_component_1(), lhs.R_component_2(), lhs.R_component_3(), lhs.R_component_4(),
sprout::array<T, 4>{{rhs.real(), rhs.imag(), static_cast<T>(0), static_cast<T>(0)}}
);
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator/(sprout::math::quaternion<T> const& lhs, sprout::math::quaternion<T> const& rhs) {
return sprout::math::detail::div_qq_impl(
lhs.R_component_1(), lhs.R_component_2(), lhs.R_component_3(), lhs.R_component_4(),
sprout::array<T, 4>{{rhs.R_component_1(), rhs.R_component_2(), rhs.R_component_3(), rhs.R_component_4()}}
);
}
//
// operator+
// operator-
//
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator+(sprout::math::quaternion<T> const& q) {
return q;
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator-(sprout::math::quaternion<T> const& q) {
return sprout::math::quaternion<T>(-q.R_component_1(), -q.R_component_2(), -q.R_component_3(), -q.R_component_4());
}
//
// operator==
// operator!=
//
template<typename T>
inline SPROUT_CONSTEXPR bool
operator==(T const& lhs, sprout::math::quaternion<T> const& rhs) {
return rhs.R_component_1() == lhs
&& rhs.R_component_2() == static_cast<T>(0)
&& rhs.R_component_3() == static_cast<T>(0)
&& rhs.R_component_4() == static_cast<T>(0)
;
}
template<typename T>
inline SPROUT_CONSTEXPR bool
operator==(sprout::math::quaternion<T> const& lhs, T const& rhs) {
return lhs.R_component_1() == rhs
&& lhs.R_component_2() == static_cast<T>(0)
&& lhs.R_component_3() == static_cast<T>(0)
&& lhs.R_component_4() == static_cast<T>(0)
;
}
template<typename T>
inline SPROUT_CONSTEXPR bool
operator==(sprout::complex<T> const& lhs, sprout::math::quaternion<T> const& rhs) {
return rhs.R_component_1() == lhs.real()
&& rhs.R_component_2() == lhs.imag()
&& rhs.R_component_3() == static_cast<T>(0)
&& rhs.R_component_4() == static_cast<T>(0)
;
}
template<typename T>
inline SPROUT_CONSTEXPR bool
operator==(sprout::math::quaternion<T> const& lhs, sprout::complex<T> const& rhs) {
return lhs.R_component_1() == rhs.real()
&& lhs.R_component_2() == rhs.imag()
&& lhs.R_component_3() == static_cast<T>(0)
&& lhs.R_component_4() == static_cast<T>(0)
;
}
template<typename T>
inline SPROUT_CONSTEXPR bool
operator==(sprout::math::quaternion<T> const& lhs, sprout::math::quaternion<T> const& rhs) {
return rhs.R_component_1() == lhs.R_component_1()
&& rhs.R_component_2() == lhs.R_component_2()
&& rhs.R_component_3() == lhs.R_component_3()
&& rhs.R_component_4() == lhs.R_component_4()
;
}
#define SPROUT_QUATERNION_NOT_EQUAL_GENERATOR \
{ \
return !(lhs == rhs); \
}
template<typename T>
inline SPROUT_CONSTEXPR bool
operator!=(T const& lhs, sprout::math::quaternion<T> const& rhs)
SPROUT_QUATERNION_NOT_EQUAL_GENERATOR
template<typename T>
inline SPROUT_CONSTEXPR bool
operator!=(sprout::math::quaternion<T> const& lhs, T const& rhs)
SPROUT_QUATERNION_NOT_EQUAL_GENERATOR
template<typename T>
inline SPROUT_CONSTEXPR bool
operator!=(sprout::complex<T> const& lhs, sprout::math::quaternion<T> const& rhs)
SPROUT_QUATERNION_NOT_EQUAL_GENERATOR
template<typename T>
inline SPROUT_CONSTEXPR bool
operator!=(sprout::math::quaternion<T> const& lhs, sprout::complex<T> const& rhs)
SPROUT_QUATERNION_NOT_EQUAL_GENERATOR
template<typename T>
inline SPROUT_CONSTEXPR bool
operator!=(sprout::math::quaternion<T> const& lhs, sprout::math::quaternion<T> const& rhs)
SPROUT_QUATERNION_NOT_EQUAL_GENERATOR
#undef SPROUT_QUATERNION_NOT_EQUAL_GENERATOR
//
// operator<<
// operator>>
//
template<typename T, typename Elem, typename Traits>
inline SPROUT_NON_CONSTEXPR std::basic_ostream<Elem, Traits>&
operator<<( std::basic_ostream<Elem, Traits>& lhs, sprout::math::quaternion<T> const& rhs) {
std::basic_ostringstream<Elem, Traits> s;
s.flags(lhs.flags());
s.imbue(lhs.getloc());
s.precision(lhs.precision());
s
<< '('
<< rhs.R_component_1() << ','
<< rhs.R_component_2() << ','
<< rhs.R_component_3() << ','
<< rhs.R_component_4()
<< ')'
;
return lhs << s.str();
}
template<typename T, typename Elem, typename Traits>
inline SPROUT_NON_CONSTEXPR std::basic_istream<Elem, Traits>&
operator>>(std::basic_istream<Elem, Traits>& lhs, sprout::math::quaternion<T>& rhs) {
std::ctype<Elem> const& ct = std::use_facet<std::ctype<Elem> >(lhs.getloc());
T a = T();
T b = T();
T c = T();
T d = T();
sprout::complex<T> u = sprout::complex<T>();
sprout::complex<T> v = sprout::complex<T>();
Elem ch = Elem();
char cc;
lhs >> ch;
if (!lhs.good()) {
goto finish;
}
cc = ct.narrow(ch, char());
if (cc == '(') {
lhs >> ch;
if (!lhs.good()) {
goto finish;
}
cc = ct.narrow(ch, char());
if (cc == '(') {
lhs.putback(ch);
lhs >> u;
a = u.real();
b = u.imag();
if (!lhs.good()) {
goto finish;
}
lhs >> ch;
if (!lhs.good()) {
goto finish;
}
cc = ct.narrow(ch, char());
if (cc == ')') {
rhs = sprout::math::quaternion<T>(a, b);
} else if (cc == ',') {
lhs >> v;
c = v.real();
d = v.imag();
if (!lhs.good()) {
goto finish;
}
lhs >> ch;
if (!lhs.good()) {
goto finish;
}
cc = ct.narrow(ch, char());
if (cc == ')') {
rhs = sprout::math::quaternion<T>(a, b, c, d);
} else {
lhs.setstate(std::ios_base::failbit);
}
} else {
lhs.setstate(std::ios_base::failbit);
}
} else {
lhs.putback(ch);
lhs >> a;
if (!lhs.good()) {
goto finish;
}
lhs >> ch;
if (!lhs.good()) {
goto finish;
}
cc = ct.narrow(ch, char());
if (cc == ')') {
rhs = sprout::math::quaternion<T>(a);
} else if (cc == ',') {
lhs >> ch;
if (!lhs.good()) {
goto finish;
}
cc = ct.narrow(ch, char());
if (cc == '(') {
lhs.putback(ch);
lhs >> v;
c = v.real();
d = v.imag();
if (!lhs.good()) {
goto finish;
}
lhs >> ch;
if (!lhs.good()) {
goto finish;
}
cc = ct.narrow(ch, char());
if (cc == ')') {
rhs = sprout::math::quaternion<T>(a, b, c, d);
} else {
lhs.setstate(std::ios_base::failbit);
}
} else {
lhs.putback(ch);
lhs >> b;
if (!lhs.good()) {
goto finish;
}
lhs >> ch;
if (!lhs.good()) {
goto finish;
}
cc = ct.narrow(ch, char());
if (cc == ')') {
rhs = sprout::math::quaternion<T>(a, b);
} else if (cc == ',') {
lhs >> c;
if (!lhs.good()) {
goto finish;
}
lhs >> ch;
if (!lhs.good()) {
goto finish;
}
cc = ct.narrow(ch, char());
if (cc == ')') {
rhs = sprout::math::quaternion<T>(a, b, c);
} else if (cc == ',') {
lhs >> d;
if (!lhs.good()) {
goto finish;
}
lhs >> ch;
if (!lhs.good()) {
goto finish;
}
cc = ct.narrow(ch, char());
if (cc == ')') {
rhs = sprout::math::quaternion<T>(a, b, c, d);
} else {
lhs.setstate(std::ios_base::failbit);
}
} else {
lhs.setstate(std::ios_base::failbit);
}
} else {
lhs.setstate(std::ios_base::failbit);
}
}
} else {
lhs.setstate(std::ios_base::failbit);
}
}
} else {
lhs.putback(ch);
lhs >> a;
if (!lhs.good()) {
goto finish;
}
rhs = sprout::math::quaternion<T>(a);
}
finish:
return lhs;
}
} // namespace math
} // namespace sprout
#endif // #ifndef SPROUT_MATH_QUATERNION_OPERATORS_HPP

44
sprout/math/quaternion/pow.hpp Normal file
View file

@ -0,0 +1,44 @@
/*=============================================================================
Copyright (c) 2011-2016 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_MATH_QUATERNION_POW_HPP
#define SPROUT_MATH_QUATERNION_POW_HPP
#include <sprout/config.hpp>
#include <sprout/math/quaternion/quaternion.hpp>
namespace sprout {
namespace math {
//
// pow
//
namespace detail {
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
pow_q_impl(sprout::math::quaternion<T> const& q, int n, int m, sprout::math::quaternion<T> const& result) {
return n != m << 1 ? result * result * q
: result * result
;
}
} // namespace detail
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
pow(sprout::math::quaternion<T> const& q, int n) {
return n > 1 ? sprout::math::detail::pow_q_impl(
q, n, n >> 1, sprout::math::pow(q, n >> 1)
)
: n == 1 ? q
: n == 0 ? sprout::math::quaternion<T>(static_cast<T>(1))
: sprout::math::pow(sprout::math::quaternion<T>(static_cast<T>(1)) / q, -n)
;
}
} // namespace math
using sprout::math::pow;
} // namespace sprout
#endif // #ifndef SPROUT_MATH_QUATERNION_POW_HPP

973
sprout/math/quaternion/quaternion.hpp
View file

@ -8,94 +8,16 @@
#ifndef SPROUT_MATH_QUATERNION_QUATERNION_HPP
#define SPROUT_MATH_QUATERNION_QUATERNION_HPP
#include <iosfwd>
#include <sstream>
#include <locale>
#include <sprout/config.hpp>
#include <sprout/workaround/std/cstddef.hpp>
#include <sprout/array/array.hpp>
#include <sprout/math/abs.hpp>
#include <sprout/math/cos.hpp>
#include <sprout/math/sin.hpp>
#include <sprout/math/cosh.hpp>
#include <sprout/math/exp.hpp>
#include <sprout/math/abs.hpp>
//#include <sprout/math/sinc.hpp>
//#include <sprout/math/sinhc.hpp>
#include <sprout/complex/complex.hpp>
#include <sprout/range/algorithm/max_element.hpp>
#include <sprout/range/numeric/accumulate.hpp>
#include <sprout/math/quaternion/detail/abs_max.hpp>
#include <sprout/math/quaternion/detail/sum.hpp>
#include <sprout/math/quaternion/detail/mul.hpp>
namespace sprout {
namespace math {
namespace detail {
template<typename T>
class abs_less {
public:
SPROUT_CONSTEXPR T
operator()(T const& lhs, T const& rhs) const {
return sprout::math::abs(lhs) < sprout::math::abs(rhs);
}
};
template<typename T>
class abs_plus {
public:
SPROUT_CONSTEXPR T
operator()(T const& lhs, T const& rhs) const {
return sprout::math::abs(lhs) + sprout::math::abs(rhs);
}
};
template<typename T, std::size_t N>
SPROUT_CONSTEXPR T
abs_max(sprout::array<T, N> const& c) {
return sprout::math::abs(*sprout::range::max_element(c, sprout::math::detail::abs_less<T>()));
}
template<typename T, std::size_t N>
SPROUT_CONSTEXPR T
sum(sprout::array<T, N> const& c) {
return sprout::range::accumulate(c, static_cast<T>(0));
}
template<typename T, std::size_t N>
SPROUT_CONSTEXPR T
abs_sum(sprout::array<T, N> const& c) {
return sprout::range::accumulate(c, static_cast<T>(0), sprout::math::detail::abs_plus<T>());
}
template<typename T>
SPROUT_CONSTEXPR sprout::array<T, 2>
mul(sprout::array<T, 2> const& l, T const& r) {
return sprout::array<T, 2>{{
l[0] * r,
l[1] * r,
}};
}
template<typename T>
SPROUT_CONSTEXPR sprout::array<T, 2>
mul(sprout::array<T, 2> const& l, sprout::array<T, 2> const& r) {
return sprout::array<T, 2>{{
l[0] * r[0],
l[1] * r[1],
}};
}
template<typename T>
SPROUT_CONSTEXPR sprout::array<T, 4>
mul(sprout::array<T, 4> const& l, T const& r) {
return sprout::array<T, 4>{{
l[0] * r,
l[1] * r,
l[2] * r,
l[3] * r
}};
}
template<typename T>
SPROUT_CONSTEXPR sprout::array<T, 4>
mul(sprout::array<T, 4> const& l, sprout::array<T, 4> const& r) {
return sprout::array<T, 4>{{
l[0] * r[0],
l[1] * r[1],
l[2] * r[2],
l[3] * r[3]
}};
}
} // namespace detail
#define SPROUT_QUATERNION_ACCESSOR_GENERATOR(type) \
SPROUT_CONSTEXPR type real() const { \
@ -839,896 +761,9 @@ namespace sprout {
#undef SPROUT_QUATERNION_MEMBER_TYPE_DATA_GENERATOR
#undef SPROUT_QUATERNION_MEMBER_ASSIGNMENT_GENERATOR
#undef SPROUT_QUATERNION_ACCESSOR_GENERATOR
//
// operator+
//
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator+(T const& lhs, sprout::math::quaternion<T> const& rhs) {
return sprout::math::quaternion<T>(
lhs + rhs.R_component_1(),
rhs.R_component_2(),
rhs.R_component_3(),
rhs.R_component_4()
);
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator+(sprout::math::quaternion<T> const& lhs, T const& rhs) {
return sprout::math::quaternion<T>(
lhs.R_component_1() + rhs,
lhs.R_component_2(),
lhs.R_component_3(),
lhs.R_component_4()
);
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator+(sprout::complex<T> const& lhs, sprout::math::quaternion<T> const& rhs) {
return sprout::math::quaternion<T>(
lhs.real() + rhs.R_component_1(),
lhs.imag() + rhs.R_component_2(),
rhs.R_component_3(),
rhs.R_component_4()
);
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator+(sprout::math::quaternion<T> const& lhs, sprout::complex<T> const& rhs) {
return sprout::math::quaternion<T>(
lhs.R_component_1() + rhs.real(),
lhs.R_component_2() + rhs.imag(),
lhs.R_component_3(),
lhs.R_component_4()
);
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator+(sprout::math::quaternion<T> const& lhs, sprout::math::quaternion<T> const& rhs) {
return sprout::math::quaternion<T>(
lhs.R_component_1() + rhs.R_component_1(),
lhs.R_component_2() + rhs.R_component_2(),
lhs.R_component_3() + rhs.R_component_3(),
lhs.R_component_4() + rhs.R_component_4()
);
}
//
// operator-
//
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator-(T const& lhs, sprout::math::quaternion<T> const& rhs) {
return sprout::math::quaternion<T>(
lhs - rhs.R_component_1(),
rhs.R_component_2(),
rhs.R_component_3(),
rhs.R_component_4()
);
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator-(sprout::math::quaternion<T> const& lhs, T const& rhs) {
return sprout::math::quaternion<T>(
lhs.R_component_1() - rhs,
lhs.R_component_2(),
lhs.R_component_3(),
lhs.R_component_4()
);
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator-(sprout::complex<T> const& lhs, sprout::math::quaternion<T> const& rhs) {
return sprout::math::quaternion<T>(
lhs.real() - rhs.R_component_1(),
lhs.imag() - rhs.R_component_2(),
rhs.R_component_3(),
rhs.R_component_4()
);
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator-(sprout::math::quaternion<T> const& lhs, sprout::complex<T> const& rhs) {
return sprout::math::quaternion<T>(
lhs.R_component_1() - rhs.real(),
lhs.R_component_2() - rhs.imag(),
lhs.R_component_3(),
lhs.R_component_4()
);
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator-(sprout::math::quaternion<T> const& lhs, sprout::math::quaternion<T> const& rhs) {
return sprout::math::quaternion<T>(
lhs.R_component_1() - rhs.R_component_1(),
lhs.R_component_2() - rhs.R_component_2(),
lhs.R_component_3() - rhs.R_component_3(),
lhs.R_component_4() - rhs.R_component_4()
);
}
//
// operator*
//
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator*(T const& lhs, sprout::math::quaternion<T> const& rhs) {
return sprout::math::quaternion<T>(
lhs * rhs.R_component_1(),
lhs * rhs.R_component_2(),
lhs * rhs.R_component_3(),
lhs * rhs.R_component_4()
);
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator*(sprout::math::quaternion<T> const& lhs, T const& rhs) {
return sprout::math::quaternion<T>(
lhs.R_component_1() * rhs,
lhs.R_component_2() * rhs,
lhs.R_component_3() * rhs,
lhs.R_component_4() * rhs
);
}
namespace detail {
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
mul_qc_impl(T const& a, T const& b, T const& c, T const& d, T const& ar, T const& br) {
return sprout::math::quaternion<T>(
+a * ar - b * br,
+a * br + b * ar,
+c * ar + d * br,
-c * br + d * ar
);
}
} // namespace detail
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator*(sprout::complex<T> const& lhs, sprout::math::quaternion<T> const& rhs) {
return sprout::math::detail::mul_qc_impl(
lhs.R_component_1(), lhs.R_component_2(), lhs.R_component_3(), lhs.R_component_4(),
rhs.real(), rhs.imag()
);
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator*(sprout::math::quaternion<T> const& lhs, sprout::complex<T> const& rhs) {
return sprout::math::detail::mul_qc_impl(
rhs.R_component_1(), rhs.R_component_2(), rhs.R_component_3(), rhs.R_component_4(),
lhs.real(), lhs.imag()
);
}
namespace detail {
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
mul_qq_impl(T const& a, T const& b, T const& c, T const& d, T const& ar, T const& br, T const& cr, T const& dr) {
return sprout::math::quaternion<T>(
+a * ar - b * br - c * cr - d * dr,
+a * br + b * ar + c * dr - d * cr,
+a * cr - b * dr + c * ar + d * br,
+a * dr + b * cr - c * br + d * ar
);
}
} // namespace detail
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator*(sprout::math::quaternion<T> const& lhs, sprout::math::quaternion<T> const& rhs) {
return sprout::math::detail::mul_qq_impl(
lhs.R_component_1(), lhs.R_component_2(), lhs.R_component_3(), lhs.R_component_4(),
rhs.R_component_1(), rhs.R_component_2(), rhs.R_component_3(), rhs.R_component_4()
);
}
//
// operator/
//
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator/(T const& lhs, sprout::math::quaternion<T> const& rhs) {
return sprout::math::quaternion<T>(
lhs / rhs.R_component_1(),
lhs / rhs.R_component_2(),
lhs / rhs.R_component_3(),
lhs / rhs.R_component_4()
);
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator/(sprout::math::quaternion<T> const& lhs, T const& rhs) {
return sprout::math::quaternion<T>(
lhs.R_component_1() / rhs,
lhs.R_component_2() / rhs,
lhs.R_component_3() / rhs,
lhs.R_component_4() / rhs
);
}
namespace detail {
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
div_qq_impl_4(sprout::array<T, 4> const& tt) {
return sprout::math::quaternion<T>(
tt[0], tt[1], tt[2], tt[3]
);
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
div_qq_impl_3(sprout::array<T, 4> const& tr, T const& mixam, sprout::array<T, 4> const& tt) {
return sprout::math::detail::div_qq_impl_3(
sprout::math::detail::mul(tt, mixam / sprout::math::detail::sum(tr))
);
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
div_qq_impl_2(T const& a, T const& b, T const& c, T const& d, sprout::array<T, 4> const& tr, T const& mixam) {
return sprout::math::detail::div_qq_impl_3(
sprout::math::detail::mul(tr, tr), mixam,
sprout::array<T, 4>{{
+a * tr[0] + b * tr[1] + c * tr[2] + d * tr[3],
-a * tr[1] + b * tr[0] - c * tr[3] + d * tr[2],
-a * tr[2] + b * tr[3] + c * tr[0] - d * tr[1],
-a * tr[3] - b * tr[2] + c * tr[1] + d * tr[0]
}}
);
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
div_qq_impl_1(T const& a, T const& b, T const& c, T const& d, sprout::array<T, 4> const& tr, T const& mixam) {
return sprout::math::detail::div_qq_impl_2(
a, b, c, d, sprout::math::detail::mul(tr, mixam), mixam
);
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
div_qq_impl(T const& a, T const& b, T const& c, T const& d, sprout::array<T, 4> const& tr) {
return sprout::math::detail::div_qq_impl_1(
a, b, c, d, tr,
static_cast<T>(1) / sprout::math::detail::abs_max(tr)
);
}
} // namespace detail
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator/(sprout::complex<T> const& lhs, sprout::math::quaternion<T> const& rhs) {
return sprout::math::detail::div_qq_impl(
lhs.real(), lhs.imag(), static_cast<T>(0), static_cast<T>(0),
sprout::array<T, 4>{{rhs.R_component_1(), rhs.R_component_2(), rhs.R_component_3(), rhs.R_component_4()}}
);
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator/(sprout::math::quaternion<T> const& lhs, sprout::complex<T> const& rhs) {
return sprout::math::detail::div_qq_impl(
lhs.R_component_1(), lhs.R_component_2(), lhs.R_component_3(), lhs.R_component_4(),
sprout::array<T, 4>{{rhs.real(), rhs.imag(), static_cast<T>(0), static_cast<T>(0)}}
);
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator/(sprout::math::quaternion<T> const& lhs, sprout::math::quaternion<T> const& rhs) {
return sprout::math::detail::div_qq_impl(
lhs.R_component_1(), lhs.R_component_2(), lhs.R_component_3(), lhs.R_component_4(),
sprout::array<T, 4>{{rhs.R_component_1(), rhs.R_component_2(), rhs.R_component_3(), rhs.R_component_4()}}
);
}
//
// operator+
// operator-
//
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator+(sprout::math::quaternion<T> const& q) {
return q;
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
operator-(sprout::math::quaternion<T> const& q) {
return sprout::math::quaternion<T>(-q.R_component_1(), -q.R_component_2(), -q.R_component_3(), -q.R_component_4());
}
//
// operator==
// operator!=
//
template<typename T>
inline SPROUT_CONSTEXPR bool
operator==(T const& lhs, sprout::math::quaternion<T> const& rhs) {
return rhs.R_component_1() == lhs
&& rhs.R_component_2() == static_cast<T>(0)
&& rhs.R_component_3() == static_cast<T>(0)
&& rhs.R_component_4() == static_cast<T>(0)
;
}
template<typename T>
inline SPROUT_CONSTEXPR bool
operator==(sprout::math::quaternion<T> const& lhs, T const& rhs) {
return lhs.R_component_1() == rhs
&& lhs.R_component_2() == static_cast<T>(0)
&& lhs.R_component_3() == static_cast<T>(0)
&& lhs.R_component_4() == static_cast<T>(0)
;
}
template<typename T>
inline SPROUT_CONSTEXPR bool
operator==(sprout::complex<T> const& lhs, sprout::math::quaternion<T> const& rhs) {
return rhs.R_component_1() == lhs.real()
&& rhs.R_component_2() == lhs.imag()
&& rhs.R_component_3() == static_cast<T>(0)
&& rhs.R_component_4() == static_cast<T>(0)
;
}
template<typename T>
inline SPROUT_CONSTEXPR bool
operator==(sprout::math::quaternion<T> const& lhs, sprout::complex<T> const& rhs) {
return lhs.R_component_1() == rhs.real()
&& lhs.R_component_2() == rhs.imag()
&& lhs.R_component_3() == static_cast<T>(0)
&& lhs.R_component_4() == static_cast<T>(0)
;
}
template<typename T>
inline SPROUT_CONSTEXPR bool
operator==(sprout::math::quaternion<T> const& lhs, sprout::math::quaternion<T> const& rhs) {
return rhs.R_component_1() == lhs.R_component_1()
&& rhs.R_component_2() == lhs.R_component_2()
&& rhs.R_component_3() == lhs.R_component_3()
&& rhs.R_component_4() == lhs.R_component_4()
;
}
#define SPROUT_QUATERNION_NOT_EQUAL_GENERATOR \
{ \
return !(lhs == rhs); \
}
template<typename T>
inline SPROUT_CONSTEXPR bool
operator!=(T const& lhs, sprout::math::quaternion<T> const& rhs)
SPROUT_QUATERNION_NOT_EQUAL_GENERATOR
template<typename T>
inline SPROUT_CONSTEXPR bool
operator!=(sprout::math::quaternion<T> const& lhs, T const& rhs)
SPROUT_QUATERNION_NOT_EQUAL_GENERATOR
template<typename T>
inline SPROUT_CONSTEXPR bool
operator!=(sprout::complex<T> const& lhs, sprout::math::quaternion<T> const& rhs)
SPROUT_QUATERNION_NOT_EQUAL_GENERATOR
template<typename T>
inline SPROUT_CONSTEXPR bool
operator!=(sprout::math::quaternion<T> const& lhs, sprout::complex<T> const& rhs)
SPROUT_QUATERNION_NOT_EQUAL_GENERATOR
template<typename T>
inline SPROUT_CONSTEXPR bool
operator!=(sprout::math::quaternion<T> const& lhs, sprout::math::quaternion<T> const& rhs)
SPROUT_QUATERNION_NOT_EQUAL_GENERATOR
#undef SPROUT_QUATERNION_NOT_EQUAL_GENERATOR
//
// operator<<
// operator>>
//
template<typename T, typename Elem, typename Traits>
inline SPROUT_NON_CONSTEXPR std::basic_ostream<Elem, Traits>&
operator<<( std::basic_ostream<Elem, Traits>& lhs, sprout::math::quaternion<T> const& rhs) {
std::basic_ostringstream<Elem, Traits> s;
s.flags(lhs.flags());
s.imbue(lhs.getloc());
s.precision(lhs.precision());
s
<< '('
<< rhs.R_component_1() << ','
<< rhs.R_component_2() << ','
<< rhs.R_component_3() << ','
<< rhs.R_component_4()
<< ')'
;
return lhs << s.str();
}
template<typename T, typename Elem, typename Traits>
inline SPROUT_NON_CONSTEXPR std::basic_istream<Elem, Traits>&
operator>>(std::basic_istream<Elem, Traits>& lhs, sprout::math::quaternion<T>& rhs) {
std::ctype<Elem> const& ct = std::use_facet<std::ctype<Elem> >(lhs.getloc());
T a = T();
T b = T();
T c = T();
T d = T();
sprout::complex<T> u = sprout::complex<T>();
sprout::complex<T> v = sprout::complex<T>();
Elem ch = Elem();
char cc;
lhs >> ch;
if (!lhs.good()) {
goto finish;
}
cc = ct.narrow(ch, char());
if (cc == '(') {
lhs >> ch;
if (!lhs.good()) {
goto finish;
}
cc = ct.narrow(ch, char());
if (cc == '(') {
lhs.putback(ch);
lhs >> u;
a = u.real();
b = u.imag();
if (!lhs.good()) {
goto finish;
}
lhs >> ch;
if (!lhs.good()) {
goto finish;
}
cc = ct.narrow(ch, char());
if (cc == ')') {
rhs = sprout::math::quaternion<T>(a, b);
} else if (cc == ',') {
lhs >> v;
c = v.real();
d = v.imag();
if (!lhs.good()) {
goto finish;
}
lhs >> ch;
if (!lhs.good()) {
goto finish;
}
cc = ct.narrow(ch, char());
if (cc == ')') {
rhs = sprout::math::quaternion<T>(a, b, c, d);
} else {
lhs.setstate(std::ios_base::failbit);
}
} else {
lhs.setstate(std::ios_base::failbit);
}
} else {
lhs.putback(ch);
lhs >> a;
if (!lhs.good()) {
goto finish;
}
lhs >> ch;
if (!lhs.good()) {
goto finish;
}
cc = ct.narrow(ch, char());
if (cc == ')') {
rhs = sprout::math::quaternion<T>(a);
} else if (cc == ',') {
lhs >> ch;
if (!lhs.good()) {
goto finish;
}
cc = ct.narrow(ch, char());
if (cc == '(') {
lhs.putback(ch);
lhs >> v;
c = v.real();
d = v.imag();
if (!lhs.good()) {
goto finish;
}
lhs >> ch;
if (!lhs.good()) {
goto finish;
}
cc = ct.narrow(ch, char());
if (cc == ')') {
rhs = sprout::math::quaternion<T>(a, b, c, d);
} else {
lhs.setstate(std::ios_base::failbit);
}
} else {
lhs.putback(ch);
lhs >> b;
if (!lhs.good()) {
goto finish;
}
lhs >> ch;
if (!lhs.good()) {
goto finish;
}
cc = ct.narrow(ch, char());
if (cc == ')') {
rhs = sprout::math::quaternion<T>(a, b);
} else if (cc == ',') {
lhs >> c;
if (!lhs.good()) {
goto finish;
}
lhs >> ch;
if (!lhs.good()) {
goto finish;
}
cc = ct.narrow(ch, char());
if (cc == ')') {
rhs = sprout::math::quaternion<T>(a, b, c);
} else if (cc == ',') {
lhs >> d;
if (!lhs.good()) {
goto finish;
}
lhs >> ch;
if (!lhs.good()) {
goto finish;
}
cc = ct.narrow(ch, char());
if (cc == ')') {
rhs = sprout::math::quaternion<T>(a, b, c, d);
} else {
lhs.setstate(std::ios_base::failbit);
}
} else {
lhs.setstate(std::ios_base::failbit);
}
} else {
lhs.setstate(std::ios_base::failbit);
}
}
} else {
lhs.setstate(std::ios_base::failbit);
}
}
} else {
lhs.putback(ch);
lhs >> a;
if (!lhs.good()) {
goto finish;
}
rhs = sprout::math::quaternion<T>(a);
}
finish:
return lhs;
}
//
// real
// unreal
//
template<typename T>
inline SPROUT_CONSTEXPR T
real(sprout::math::quaternion<T> const& q) {
return q.real();
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
unreal(sprout::math::quaternion<T> const& q) {
return q.unreal();
}
//
// sup
// l1
//
template<typename T>
inline SPROUT_CONSTEXPR T
sup(sprout::math::quaternion<T> const& q) {
return sprout::math::detail::abs_max(
sprout::array<T, 4>{{
q.R_component_1(),
q.R_component_2(),
q.R_component_3(),
q.R_component_4()
}}
);
}
template<typename T>
inline SPROUT_CONSTEXPR T
l1(sprout::math::quaternion<T> const& q) {
return sprout::math::detail::abs_sum(
sprout::array<T, 4>{{
q.R_component_1(),
q.R_component_2(),
q.R_component_3(),
q.R_component_4()
}}
);
}
//
// abs
//
namespace detail {
template<typename T>
inline SPROUT_CONSTEXPR T
abs_q_impl_3(sprout::array<T, 4> const& temp, T const& maxim) {
return maxim * sprout::math::sqrt(sprout::math::detail::sum(sprout::math::detail::mul(temp, temp)));
}
template<typename T>
inline SPROUT_CONSTEXPR T
abs_q_impl_2(sprout::array<T, 4> const& temp, T const& maxim) {
return sprout::math::detail::abs_q_impl_3(
sprout::math::detail::mul(temp, maxim), maxim
);
}
template<typename T>
inline SPROUT_CONSTEXPR T
abs_q_impl_1(sprout::array<T, 4> const& temp, T const& maxim) {
return maxim == static_cast<T>(0) ? sprout::math::quaternion<T>(maxim)
: sprout::math::detail::abs_q_impl_2(
temp, static_cast<T>(1) / maxim
)
;
}
template<typename T>
inline SPROUT_CONSTEXPR T
abs_q_impl(sprout::array<T, 4> const& temp) {
return sprout::math::detail::abs_q_impl_1(
temp, sprout::math::detail::abs_max(temp)
);
}
} // namespace detail
template<typename T>
inline SPROUT_CONSTEXPR T
abs(sprout::math::quaternion<T> const& q) {
return sprout::math::detail::abs_q_impl(
sprout::array<T, 4>{{
q.R_component_1(),
q.R_component_2(),
q.R_component_3(),
q.R_component_4()
}}
);
}
#undef SPROUT_QUATERNION_ARRAY_LOADER
//
// conj
// norm
//
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
conj(sprout::math::quaternion<T> const& q) {
return sprout::math::quaternion<T>(
+q.R_component_1(),
-q.R_component_2(),
-q.R_component_3(),
-q.R_component_4()
);
}
template<typename T>
inline SPROUT_CONSTEXPR T
norm(sprout::math::quaternion<T> const& q) {
return sprout::math::real(q * sprout::math::conj(q));
}
//
// spherical
// semipolar
// multipolar
// cylindrospherical
// cylindrical
//
namespace detail {
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
spherical_impl(T const& rho, T const& theta, T const& phi1, T const& phi2, T const& p1, T const& p2) {
return rho * sprout::math::quaternion<T>(
sprout::math::cos(theta) * (p2 * p1),
sprout::math::sin(theta) * (p2 * p1),
sprout::math::sin(phi1) * p2,
sprout::math::sin(phi2)
);
}
} // namespace detail
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
spherical(T const& rho, T const& theta, T const& phi1, T const& phi2) {
return sprout::math::detail::spherical_impl(
rho, theta, phi1, phi2,
sprout::math::cos(phi1), sprout::math::cos(phi2)
);
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
semipolar(T const& rho, T const& alpha, T const& theta1, T const& theta2) {
return rho * sprout::math::quaternion<T>(
sprout::math::cos(alpha) * sprout::math::cos(theta1),
sprout::math::cos(alpha) * sprout::math::sin(theta1),
sprout::math::sin(alpha) * sprout::math::cos(theta2),
sprout::math::sin(alpha) * sprout::math::sin(theta2)
);
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
multipolar(T const& rho1, T const& theta1, T const& rho2, T const& theta2) {
return sprout::math::quaternion<T>(
rho1 * sprout::math::cos(theta1),
rho1 * sprout::math::sin(theta1),
rho2 * sprout::math::cos(theta2),
rho2 * sprout::math::sin(theta2)
);
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
cylindrospherical(T const& t, T const& radius, T const& longitude, T const& latitude) {
return sprout::math::quaternion<T>(
t,
radius * sprout::math::cos(longitude) * sprout::math::cos(latitude),
radius * sprout::math::sin(longitude) * sprout::math::cos(latitude),
radius * sprout::math::sin(latitude)
);
}
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
cylindrical(T const& r, T const& angle, T const& h1, T const& h2) {
return sprout::math::quaternion<T>(
r * sprout::math::cos(angle),
r * sprout::math::sin(angle),
h1,
h2
);
}
//
// exp
//
// !!!
// namespace detail {
// template<typename T>
// inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
// exp_impl_1(sprout::math::quaternion<T> const& q, T const& z, T const& w) {
// return sprout::math::exp(sprout::math::real(q)) * sprout::math::quaternion<T>(
// sprout::math::cos(z),
// w * q.R_component_2(),
// w * q.R_component_3(),
// w * q.R_component_4()
// );
// }
// template<typename T>
// inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
// exp_impl(sprout::math::quaternion<T> const& q, T const& z) {
// return sprout::math::detail::exp_impl_1(
// q, z,
// sprout::math::sinc_pi(z)
// );
// }
// } // namespace detail
// inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
// exp(sprout::math::quaternion<T> const& q) {
// return sprout::math::detail::exp_impl(
// q,
// sprout::math::abs(sprout::math::unreal(q))
// );
// }
//
// cos
// sin
// tan
//
// !!!
// namespace detail {
// template<typename T>
// inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
// cos_impl_1(sprout::math::quaternion<T> const& q, T const& z, T const& w) {
// return sprout::math::quaternion<T>(
// sprout::math::cos(q.real()) * sprout::math::cosh(z),
// w * q.R_component_2(),
// w * q.R_component_3(),
// w * q.R_component_4()
// );
// }
// template<typename T>
// inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
// cos_impl(sprout::math::quaternion<T> const& q, T const& z) {
// return sprout::math::detail::cos_impl_1(
// q, z,
// -sprout::math::sin(q.real()) * sprout::math::sinhc_pi(z)
// );
// }
// } // namespace detail
// template<typename T>
// inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
// cos(sprout::math::quaternion<T> const& q) {
// return sprout::math::detail::cos_impl(
// q,
// sprout::math::abs(sprout::math::unreal(q))
// );
// }
// namespace detail {
// template<typename T>
// inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
// sin_impl_1(sprout::math::quaternion<T> const& q, T const& z, T const& w) {
// return sprout::math::quaternion<T>(
// sprout::math::sin(q.real()) * sprout::math::cosh(z),
// w * q.R_component_2(),
// w * q.R_component_3(),
// w * q.R_component_4()
// );
// }
// template<typename T>
// inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
// sin_impl(sprout::math::quaternion<T> const& q, T const& z) {
// return sprout::math::detail::sin_impl_1(
// q, z,
// +sprout::math::cos(q.real()) * sprout::math::sinhc_pi(z)
// );
// }
// } // namespace detail
// template<typename T>
// inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
// sin(sprout::math::quaternion<T> const& q) {
// return sprout::math::detail::sin_impl(
// q,
// sprout::math::abs(sprout::math::unreal(q))
// );
// }
// template<typename T>
// inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
// tan(sprout::math::quaternion<T> const& q) {
// return sprout::math::sin(q) / sprout::math::cos(q);
// }
//
// cosh
// sinh
// tanh
//
// !!!
// template<typename T>
// inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
// cosh(sprout::math::quaternion<T> const& q) {
// return (sprout::math::exp(+q) + sprout::math::exp(-q)) / static_cast<T>(2);
// }
// template<typename T>
// inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
// sinh(sprout::math::quaternion<T> const& q) {
// return (sprout::math::exp(+q) - sprout::math::exp(-q)) / static_cast<T>(2);
// }
// template<typename T>
// inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
// tanh(sprout::math::quaternion<T> const& q) {
// return sprout::math::sinh(q) / sprout::math::cosh(q);
// }
//
// pow
//
namespace detail {
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
pow_q_impl(sprout::math::quaternion<T> const& q, int n, int m, sprout::math::quaternion<T> const& result) {
return n != m << 1 ? result * result * q
: result * result
;
}
} // namespace detail
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
pow(sprout::math::quaternion<T> const& q, int n) {
return n > 1 ? sprout::math::detail::pow_q_impl(
q, n, n >> 1, sprout::math::pow(q, n >> 1)
)
: n == 1 ? q
: n == 0 ? sprout::math::quaternion<T>(static_cast<T>(1))
: sprout::math::pow(sprout::math::quaternion<T>(static_cast<T>(1)) / q, -n)
;
}
} // namespace math
using sprout::math::quaternion;
using sprout::math::real;
using sprout::math::unreal;
using sprout::math::sup;
using sprout::math::l1;
using sprout::math::abs;
using sprout::math::conj;
using sprout::math::norm;
using sprout::math::spherical;
using sprout::math::semipolar;
using sprout::math::multipolar;
using sprout::math::cylindrospherical;
using sprout::math::cylindrical;
// using sprout::math::exp;
// using sprout::math::cos;
// using sprout::math::sin;
// using sprout::math::tan;
// using sprout::math::cosh;
// using sprout::math::sinh;
// using sprout::math::tanh;
using sprout::math::pow;
} // namespace sprout
#endif // #ifndef SPROUT_MATH_QUATERNION_QUATERNION_HPP

29
sprout/math/quaternion/real.hpp Normal file
View file

@ -0,0 +1,29 @@
/*=============================================================================
Copyright (c) 2011-2016 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_MATH_QUATERNION_REAL_HPP
#define SPROUT_MATH_QUATERNION_REAL_HPP
#include <sprout/config.hpp>
#include <sprout/math/quaternion/quaternion.hpp>
namespace sprout {
namespace math {
//
// real
//
template<typename T>
inline SPROUT_CONSTEXPR T
real(sprout::math::quaternion<T> const& q) {
return q.real();
}
} // namespace math
using sprout::math::real;
} // namespace sprout
#endif // #ifndef SPROUT_MATH_QUATERNION_REAL_HPP

36
sprout/math/quaternion/semipolar.hpp Normal file
View file

@ -0,0 +1,36 @@
/*=============================================================================
Copyright (c) 2011-2016 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_MATH_QUATERNION_SEMIPOLAR_HPP
#define SPROUT_MATH_QUATERNION_SEMIPOLAR_HPP
#include <sprout/config.hpp>
#include <sprout/math/cos.hpp>
#include <sprout/math/sin.hpp>
#include <sprout/math/quaternion/quaternion.hpp>
namespace sprout {
namespace math {
//
// semipolar
//
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
semipolar(T const& rho, T const& alpha, T const& theta1, T const& theta2) {
return rho * sprout::math::quaternion<T>(
sprout::math::cos(alpha) * sprout::math::cos(theta1),
sprout::math::cos(alpha) * sprout::math::sin(theta1),
sprout::math::sin(alpha) * sprout::math::cos(theta2),
sprout::math::sin(alpha) * sprout::math::sin(theta2)
);
}
} // namespace math
using sprout::math::semipolar;
} // namespace sprout
#endif // #ifndef SPROUT_MATH_QUATERNION_SEMIPOLAR_HPP

60
sprout/math/quaternion/sin.hpp Normal file
View file

@ -0,0 +1,60 @@
/*=============================================================================
Copyright (c) 2011-2016 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_MATH_QUATERNION_SIN_HPP
#define SPROUT_MATH_QUATERNION_SIN_HPP
#include <sprout/config.hpp>
#include <sprout/math/cos.hpp>
#include <sprout/math/sin.hpp>
#include <sprout/math/cosh.hpp>
//#include <sprout/math/sinhc.hpp>
#include <sprout/math/quaternion/quaternion.hpp>
#include <sprout/math/quaternion/real.hpp>
#include <sprout/math/quaternion/unreal.hpp>
#include <sprout/math/quaternion/abs.hpp>
namespace sprout {
namespace math {
//
// sin
//
// !!!
// namespace detail {
// template<typename T>
// inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
// sin_impl_1(sprout::math::quaternion<T> const& q, T const& z, T const& w) {
// return sprout::math::quaternion<T>(
// sprout::math::sin(sprout::math::real(q)) * sprout::math::cosh(z),
// w * q.R_component_2(),
// w * q.R_component_3(),
// w * q.R_component_4()
// );
// }
// template<typename T>
// inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
// sin_impl(sprout::math::quaternion<T> const& q, T const& z) {
// return sprout::math::detail::sin_impl_1(
// q, z,
// +sprout::math::cos(sprout::math::real(q)) * sprout::math::sinhc_pi(z)
// );
// }
// } // namespace detail
// template<typename T>
// inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
// sin(sprout::math::quaternion<T> const& q) {
// return sprout::math::detail::sin_impl(
// q,
// sprout::math::abs(sprout::math::unreal(q))
// );
// }
} // namespace math
// using sprout::math::sin;
} // namespace sprout
#endif // #ifndef SPROUT_MATH_QUATERNION_SIN_HPP

31
sprout/math/quaternion/sinh.hpp Normal file
View file

@ -0,0 +1,31 @@
/*=============================================================================
Copyright (c) 2011-2016 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_MATH_QUATERNION_SINH_HPP
#define SPROUT_MATH_QUATERNION_SINH_HPP
#include <sprout/config.hpp>
#include <sprout/math/quaternion/quaternion.hpp>
#include <sprout/math/quaternion/exp.hpp>
namespace sprout {
namespace math {
//
// sinh
//
// !!!
// template<typename T>
// inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
// sinh(sprout::math::quaternion<T> const& q) {
// return (sprout::math::exp(+q) - sprout::math::exp(-q)) / static_cast<T>(2);
// }
} // namespace math
// using sprout::math::sinh;
} // namespace sprout
#endif // #ifndef SPROUT_MATH_QUATERNION_SINH_HPP

46
sprout/math/quaternion/spherical.hpp Normal file
View file

@ -0,0 +1,46 @@
/*=============================================================================
Copyright (c) 2011-2016 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_MATH_QUATERNION_SPHERICAL_HPP
#define SPROUT_MATH_QUATERNION_SPHERICAL_HPP
#include <sprout/config.hpp>
#include <sprout/math/cos.hpp>
#include <sprout/math/sin.hpp>
#include <sprout/math/quaternion/quaternion.hpp>
namespace sprout {
namespace math {
//
// spherical
//
namespace detail {
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
spherical_impl(T const& rho, T const& theta, T const& phi1, T const& phi2, T const& p1, T const& p2) {
return rho * sprout::math::quaternion<T>(
sprout::math::cos(theta) * (p2 * p1),
sprout::math::sin(theta) * (p2 * p1),
sprout::math::sin(phi1) * p2,
sprout::math::sin(phi2)
);
}
} // namespace detail
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
spherical(T const& rho, T const& theta, T const& phi1, T const& phi2) {
return sprout::math::detail::spherical_impl(
rho, theta, phi1, phi2,
sprout::math::cos(phi1), sprout::math::cos(phi2)
);
}
} // namespace math
using sprout::math::spherical;
} // namespace sprout
#endif // #ifndef SPROUT_MATH_QUATERNION_SPHERICAL_HPP

38
sprout/math/quaternion/sup.hpp Normal file
View file

@ -0,0 +1,38 @@
/*=============================================================================
Copyright (c) 2011-2016 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_MATH_QUATERNION_SUP_HPP
#define SPROUT_MATH_QUATERNION_SUP_HPP
#include <sprout/config.hpp>
#include <sprout/array/array.hpp>
#include <sprout/math/quaternion/quaternion.hpp>
#include <sprout/math/quaternion/detail/abs_max.hpp>
namespace sprout {
namespace math {
//
// sup
//
template<typename T>
inline SPROUT_CONSTEXPR T
sup(sprout::math::quaternion<T> const& q) {
return sprout::math::detail::abs_max(
sprout::array<T, 4>{{
q.R_component_1(),
q.R_component_2(),
q.R_component_3(),
q.R_component_4()
}}
);
}
} // namespace math
using sprout::math::sup;
} // namespace sprout
#endif // #ifndef SPROUT_MATH_QUATERNION_SUP_HPP

32
sprout/math/quaternion/tan.hpp Normal file
View file

@ -0,0 +1,32 @@
/*=============================================================================
Copyright (c) 2011-2016 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_MATH_QUATERNION_TAN_HPP
#define SPROUT_MATH_QUATERNION_TAN_HPP
#include <sprout/config.hpp>
#include <sprout/math/quaternion/quaternion.hpp>
#include <sprout/math/quaternion/cos.hpp>
#include <sprout/math/quaternion/sin.hpp>
namespace sprout {
namespace math {
//
// tan
//
// !!!
// template<typename T>
// inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
// tan(sprout::math::quaternion<T> const& q) {
// return sprout::math::sin(q) / sprout::math::cos(q);
// }
} // namespace math
// using sprout::math::tan;
} // namespace sprout
#endif // #ifndef SPROUT_MATH_QUATERNION_TAN_HPP

32
sprout/math/quaternion/tanh.hpp Normal file
View file

@ -0,0 +1,32 @@
/*=============================================================================
Copyright (c) 2011-2016 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_MATH_QUATERNION_TANH_HPP
#define SPROUT_MATH_QUATERNION_TANH_HPP
#include <sprout/config.hpp>
#include <sprout/math/quaternion/quaternion.hpp>
#include <sprout/math/quaternion/cosh.hpp>
#include <sprout/math/quaternion/sinh.hpp>
namespace sprout {
namespace math {
//
// tanh
//
// !!!
// template<typename T>
// inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
// tanh(sprout::math::quaternion<T> const& q) {
// return sprout::math::sinh(q) / sprout::math::cosh(q);
// }
} // namespace math
// using sprout::math::tanh;
} // namespace sprout
#endif // #ifndef SPROUT_MATH_QUATERNION_TANH_HPP

21
sprout/math/quaternion/transcendentals.hpp Normal file
View file

@ -0,0 +1,21 @@
/*=============================================================================
Copyright (c) 2011-2016 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_MATH_QUATERNION_TRANSCENDENTALS_HPP
#define SPROUT_MATH_QUATERNION_TRANSCENDENTALS_HPP
#include <sprout/config.hpp>
#include <sprout/math/quaternion/exp.hpp>
#include <sprout/math/quaternion/cos.hpp>
#include <sprout/math/quaternion/sin.hpp>
#include <sprout/math/quaternion/tan.hpp>
#include <sprout/math/quaternion/cosh.hpp>
#include <sprout/math/quaternion/sinh.hpp>
#include <sprout/math/quaternion/tanh.hpp>
#include <sprout/math/quaternion/pow.hpp>
#endif // #ifndef SPROUT_MATH_QUATERNION_TRANSCENDENTALS_HPP

139
sprout/math/quaternion/tuple.hpp Normal file
View file

@ -0,0 +1,139 @@
/*=============================================================================
Copyright (c) 2011-2016 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_MATH_QUATERNION_TUPLE_HPP
#define SPROUT_MATH_QUATERNION_TUPLE_HPP
#include <sprout/config.hpp>
#include <sprout/workaround/std/cstddef.hpp>
#include <sprout/math/quaternion/quaternion.hpp>
#include <sprout/utility/move.hpp>
#include <sprout/type_traits/integral_constant.hpp>
#include <sprout/type_traits/identity.hpp>
#include <sprout/detail/nil_base.hpp>
namespace sprout {
namespace tuples {
namespace detail {
template<std::size_t I, typename T>
struct tuple_element_impl;
template<std::size_t I, typename T>
struct tuple_element_impl<I, sprout::math::quaternion<T> >
: public sprout::detail::nil_base
{};
template<typename T>
struct tuple_element_impl<0, sprout::math::quaternion<T> >
: public sprout::identity<T>
{};
template<typename T>
struct tuple_element_impl<1, sprout::math::quaternion<T> >
: public sprout::identity<T>
{};
template<typename T>
struct tuple_element_impl<2, sprout::math::quaternion<T> >
: public sprout::identity<T>
{};
template<typename T>
struct tuple_element_impl<3, sprout::math::quaternion<T> >
: public sprout::identity<T>
{};
template<std::size_t I, typename T>
struct get_impl;
template<typename T>
struct get_impl<0, sprout::math::quaternion<T> > {
public:
SPROUT_CONSTEXPR T& operator()(sprout::math::quaternion<T>& t) const {
return t[0];
}
SPROUT_CONSTEXPR T const& operator()(sprout::math::quaternion<T> const& t) const {
return t[0];
}
};
template<typename T>
struct get_impl<1, sprout::math::quaternion<T> > {
public:
SPROUT_CONSTEXPR T& operator()(sprout::math::quaternion<T>& t) const {
return t[1];
}
SPROUT_CONSTEXPR T const& operator()(sprout::math::quaternion<T> const& t) const {
return t[1];
}
};
template<typename T>
struct get_impl<2, sprout::math::quaternion<T> > {
public:
SPROUT_CONSTEXPR T& operator()(sprout::math::quaternion<T>& t) const {
return t[2];
}
SPROUT_CONSTEXPR T const& operator()(sprout::math::quaternion<T> const& t) const {
return t[2];
}
};
template<typename T>
struct get_impl<3, sprout::math::quaternion<T> > {
public:
SPROUT_CONSTEXPR T& operator()(sprout::math::quaternion<T>& t) const {
return t[3];
}
SPROUT_CONSTEXPR T const& operator()(sprout::math::quaternion<T> const& t) const {
return t[3];
}
};
} // namespace detail
} // namespace tuples
} // namespace sprout
namespace std {
#if defined(__clang__)
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Wmismatched-tags"
#endif
//
// tuple_size
//
template<typename T>
struct tuple_size<sprout::math::quaternion<T> >
: public sprout::integral_constant<std::size_t, 4>
{};
//
// tuple_element
//
template<std::size_t I, typename T>
struct tuple_element<I, sprout::math::quaternion<T> >
: public sprout::tuples::detail::tuple_element_impl<I, sprout::math::quaternion<T> >
{};
#if defined(__clang__)
# pragma clang diagnostic pop
#endif
} // namespace std
namespace sprout {
//
// tuple_get
//
template<std::size_t I, typename T>
inline SPROUT_CONSTEXPR typename sprout::tuples::tuple_element<I, sprout::math::quaternion<T> >::type&
tuple_get(sprout::math::quaternion<T>& t) SPROUT_NOEXCEPT {
static_assert(I < 4, "tuple_get: index out of range");
return sprout::tuples::detail::get_impl<I, sprout::math::quaternion<T> >()(t);
}
template<std::size_t I, typename T>
inline SPROUT_CONSTEXPR typename sprout::tuples::tuple_element<I, sprout::math::quaternion<T> >::type const&
tuple_get(sprout::math::quaternion<T> const& t) SPROUT_NOEXCEPT {
static_assert(I < 4, "tuple_get: index out of range");
return sprout::tuples::detail::get_impl<I, sprout::math::quaternion<T> >()(t);
}
template<std::size_t I, typename T>
inline SPROUT_CONSTEXPR typename sprout::tuples::tuple_element<I, sprout::math::quaternion<T> >::type&&
tuple_get(sprout::math::quaternion<T>&& t) SPROUT_NOEXCEPT {
return sprout::move(sprout::tuples::get<I>(t));
}
} // namespace sprout
#endif // #ifndef SPROUT_MATH_QUATERNION_TUPLE_HPP

49
sprout/math/quaternion/type_traits.hpp Normal file
View file

@ -0,0 +1,49 @@
/*=============================================================================
Copyright (c) 2011-2016 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_MATH_QUATERNION_TYPE_TRAITS_HPP
#define SPROUT_MATH_QUATERNION_TYPE_TRAITS_HPP
#include <sprout/config.hpp>
#include <sprout/math/quaternion/quaternion.hpp>
#include <sprout/type_traits/integral_constant.hpp>
namespace sprout {
namespace math {
//
// is_quaternion
//
template<typename T>
struct is_quaternion
: public sprout::false_type
{};
template<typename T>
struct is_quaternion<T const>
: public sprout::math::is_quaternion<T>
{};
template<typename T>
struct is_quaternion<T const volatile>
: public sprout::math::is_quaternion<T>
{};
template<typename T>
struct is_quaternion<sprout::math::quaternion<T> >
: public sprout::true_type
{};
#if SPROUT_USE_VARIABLE_TEMPLATES
template<typename T>
SPROUT_STATIC_CONSTEXPR bool is_quaternion_v = sprout::math::is_quaternion<T>::value;
#endif // #if SPROUT_USE_VARIABLE_TEMPLATES
} // namespace math
using sprout::math::is_quaternion;
#if SPROUT_USE_VARIABLE_TEMPLATES
using sprout::math::is_quaternion_v;
#endif // #if SPROUT_USE_VARIABLE_TEMPLATES
} // namespace sprout
#endif // #ifndef SPROUT_MATH_QUATERNION_TYPE_TRAITS_HPP

123
sprout/math/quaternion/udl.hpp Normal file
View file

@ -0,0 +1,123 @@
/*=============================================================================
Copyright (c) 2011-2016 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_MATH_QUATERNION_UDL_HPP
#define SPROUT_MATH_QUATERNION_UDL_HPP
#include <sprout/config.hpp>
#include <sprout/complex/udl.hpp>
#include <sprout/math/quaternion/quaternion.hpp>
#if SPROUT_USE_USER_DEFINED_LITERALS
namespace sprout {
namespace udl {
namespace quaternion {
using sprout::udl::complex::operator"" _i;
using sprout::udl::complex::operator"" _if;
using sprout::udl::complex::operator"" _iF;
using sprout::udl::complex::operator"" _il;
using sprout::udl::complex::operator"" _iL;
//
// _j
//
inline SPROUT_CONSTEXPR sprout::math::quaternion<double>
operator"" _j(long double x) {
return sprout::math::quaternion<double>(0, 0, x);
}
//
// _jf
// _jF
//
inline SPROUT_CONSTEXPR sprout::math::quaternion<float>
operator"" _jf(long double x) {
return sprout::math::quaternion<float>(0, 0, static_cast<float>(x));
}
inline SPROUT_CONSTEXPR sprout::math::quaternion<float>
operator"" _jF(long double x) {
return sprout::math::quaternion<float>(0, 0, static_cast<float>(x));
}
//
// _jl
// _jL
//
inline SPROUT_CONSTEXPR sprout::math::quaternion<long double>
operator"" _jl(long double x) {
return sprout::math::quaternion<long double>(0, 0, x);
}
inline SPROUT_CONSTEXPR sprout::math::quaternion<long double>
operator"" _jL(long double x) {
return sprout::math::quaternion<long double>(0, 0, x);
}
//
// _k
//
inline SPROUT_CONSTEXPR sprout::math::quaternion<double>
operator"" _k(long double x) {
return sprout::math::quaternion<double>(0, 0, 0, x);
}
//
// _kf
// _kF
//
inline SPROUT_CONSTEXPR sprout::math::quaternion<float>
operator"" _kf(long double x) {
return sprout::math::quaternion<float>(0, 0, 0, static_cast<float>(x));
}
inline SPROUT_CONSTEXPR sprout::math::quaternion<float>
operator"" _kF(long double x) {
return sprout::math::quaternion<float>(0, 0, 0, static_cast<float>(x));
}
//
// _kl
// _kL
//
inline SPROUT_CONSTEXPR sprout::math::quaternion<long double>
operator"" _kl(long double x) {
return sprout::math::quaternion<long double>(0, 0, 0, x);
}
inline SPROUT_CONSTEXPR sprout::math::quaternion<long double>
operator"" _kL(long double x) {
return sprout::math::quaternion<long double>(0, 0, 0, x);
}
} // namespace quaternion
using sprout::udl::quaternion::operator"" _j;
using sprout::udl::quaternion::operator"" _jf;
using sprout::udl::quaternion::operator"" _jF;
using sprout::udl::quaternion::operator"" _jl;
using sprout::udl::quaternion::operator"" _jL;
using sprout::udl::quaternion::operator"" _k;
using sprout::udl::quaternion::operator"" _kf;
using sprout::udl::quaternion::operator"" _kF;
using sprout::udl::quaternion::operator"" _kl;
using sprout::udl::quaternion::operator"" _kL;
} // namespace udl
using sprout::udl::quaternion::operator"" _j;
using sprout::udl::quaternion::operator"" _jf;
using sprout::udl::quaternion::operator"" _jF;
using sprout::udl::quaternion::operator"" _jl;
using sprout::udl::quaternion::operator"" _jL;
using sprout::udl::quaternion::operator"" _k;
using sprout::udl::quaternion::operator"" _kf;
using sprout::udl::quaternion::operator"" _kF;
using sprout::udl::quaternion::operator"" _kl;
using sprout::udl::quaternion::operator"" _kL;
} // namespace sprout
#endif // #if SPROUT_USE_USER_DEFINED_LITERALS
#endif // #ifndef SPROUT_MATH_QUATERNION_UDL_HPP

29
sprout/math/quaternion/unreal.hpp Normal file
View file

@ -0,0 +1,29 @@
/*=============================================================================
Copyright (c) 2011-2016 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_MATH_QUATERNION_UNREAL_HPP
#define SPROUT_MATH_QUATERNION_UNREAL_HPP
#include <sprout/config.hpp>
#include <sprout/math/quaternion/quaternion.hpp>
namespace sprout {
namespace math {
//
// unreal
//
template<typename T>
inline SPROUT_CONSTEXPR sprout::math::quaternion<T>
unreal(sprout::math::quaternion<T> const& q) {
return q.unreal();
}
} // namespace math
using sprout::math::unreal;
} // namespace sprout
#endif // #ifndef SPROUT_MATH_QUATERNION_UNREAL_HPP

20
sprout/math/quaternion/values.hpp Normal file
View file

@ -0,0 +1,20 @@
/*=============================================================================
Copyright (c) 2011-2016 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_MATH_QUATERNION_VALUES_HPP
#define SPROUT_MATH_QUATERNION_VALUES_HPP
#include <sprout/config.hpp>
#include <sprout/math/quaternion/real.hpp>
#include <sprout/math/quaternion/unreal.hpp>
#include <sprout/math/quaternion/sup.hpp>
#include <sprout/math/quaternion/l1.hpp>
#include <sprout/math/quaternion/abs.hpp>
#include <sprout/math/quaternion/conj.hpp>
#include <sprout/math/quaternion/norm.hpp>
#endif // #ifndef SPROUT_MATH_QUATERNION_VALUES_HPP