// | |
// Copyright (c) 2000-2002 | |
// Joerg Walter, Mathias Koch | |
// | |
// 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) | |
// | |
// The authors gratefully acknowledge the support of | |
// GeNeSys mbH & Co. KG in producing this work. | |
// | |
#ifndef _BOOST_UBLAS_TRAITS_ | |
#define _BOOST_UBLAS_TRAITS_ | |
#include <iterator> | |
#include <complex> | |
#include <boost/config/no_tr1/cmath.hpp> | |
#include <boost/numeric/ublas/detail/config.hpp> | |
#include <boost/numeric/ublas/detail/iterator.hpp> | |
#include <boost/numeric/ublas/detail/returntype_deduction.hpp> | |
#include <boost/type_traits.hpp> | |
#include <complex> | |
#include <boost/typeof/typeof.hpp> | |
#include <boost/utility/enable_if.hpp> | |
#include <boost/type_traits/is_float.hpp> | |
#include <boost/type_traits/is_integral.hpp> | |
#include <boost/mpl/and.hpp> | |
// anonymous namespace to avoid ADL issues | |
namespace { | |
template<class T> T boost_numeric_ublas_sqrt (const T& t) { | |
using namespace std; | |
// we'll find either std::sqrt or else another version via ADL: | |
return sqrt (t); | |
} | |
template<class T> T boost_numeric_ublas_abs (const T& t) { | |
using namespace std; | |
// we'll find either std::abs or else another version via ADL: | |
return abs (t); | |
} | |
} | |
namespace boost { namespace numeric { namespace ublas { | |
// Use Joel de Guzman's return type deduction | |
// uBLAS assumes a common return type for all binary arithmetic operators | |
template<class X, class Y> | |
struct promote_traits { | |
typedef type_deduction_detail::base_result_of<X, Y> base_type; | |
static typename base_type::x_type x; | |
static typename base_type::y_type y; | |
static const std::size_t size = sizeof ( | |
type_deduction_detail::test< | |
typename base_type::x_type | |
, typename base_type::y_type | |
>(x + y) // Use x+y to stand of all the arithmetic actions | |
); | |
static const std::size_t index = (size / sizeof (char)) - 1; | |
typedef typename mpl::at_c< | |
typename base_type::types, index>::type id; | |
typedef typename id::type promote_type; | |
}; | |
template<typename R, typename I> | |
typename boost::enable_if< | |
mpl::and_< | |
boost::is_float<R>, | |
boost::is_integral<I> | |
>, | |
std::complex<R> >::type inline operator+ (I in1, std::complex<R> const& in2 ) { | |
return R (in1) + in2; | |
} | |
template<typename R, typename I> | |
typename boost::enable_if< | |
mpl::and_< | |
boost::is_float<R>, | |
boost::is_integral<I> | |
>, | |
std::complex<R> >::type inline operator+ (std::complex<R> const& in1, I in2) { | |
return in1 + R (in2); | |
} | |
template<typename R, typename I> | |
typename boost::enable_if< | |
mpl::and_< | |
boost::is_float<R>, | |
boost::is_integral<I> | |
>, | |
std::complex<R> >::type inline operator- (I in1, std::complex<R> const& in2) { | |
return R (in1) - in2; | |
} | |
template<typename R, typename I> | |
typename boost::enable_if< | |
mpl::and_< | |
boost::is_float<R>, | |
boost::is_integral<I> | |
>, | |
std::complex<R> >::type inline operator- (std::complex<R> const& in1, I in2) { | |
return in1 - R (in2); | |
} | |
template<typename R, typename I> | |
typename boost::enable_if< | |
mpl::and_< | |
boost::is_float<R>, | |
boost::is_integral<I> | |
>, | |
std::complex<R> >::type inline operator* (I in1, std::complex<R> const& in2) { | |
return R (in1) * in2; | |
} | |
template<typename R, typename I> | |
typename boost::enable_if< | |
mpl::and_< | |
boost::is_float<R>, | |
boost::is_integral<I> | |
>, | |
std::complex<R> >::type inline operator* (std::complex<R> const& in1, I in2) { | |
return in1 * R(in2); | |
} | |
template<typename R, typename I> | |
typename boost::enable_if< | |
mpl::and_< | |
boost::is_float<R>, | |
boost::is_integral<I> | |
>, | |
std::complex<R> >::type inline operator/ (I in1, std::complex<R> const& in2) { | |
return R(in1) / in2; | |
} | |
template<typename R, typename I> | |
typename boost::enable_if< | |
mpl::and_< | |
boost::is_float<R>, | |
boost::is_integral<I> | |
>, | |
std::complex<R> >::type inline operator/ (std::complex<R> const& in1, I in2) { | |
return in1 / R (in2); | |
} | |
// Type traits - generic numeric properties and functions | |
template<class T> | |
struct type_traits; | |
// Define properties for a generic scalar type | |
template<class T> | |
struct scalar_traits { | |
typedef scalar_traits<T> self_type; | |
typedef T value_type; | |
typedef const T &const_reference; | |
typedef T &reference; | |
typedef T real_type; | |
typedef real_type precision_type; // we do not know what type has more precision then the real_type | |
static const unsigned plus_complexity = 1; | |
static const unsigned multiplies_complexity = 1; | |
static | |
BOOST_UBLAS_INLINE | |
real_type real (const_reference t) { | |
return t; | |
} | |
static | |
BOOST_UBLAS_INLINE | |
real_type imag (const_reference /*t*/) { | |
return 0; | |
} | |
static | |
BOOST_UBLAS_INLINE | |
value_type conj (const_reference t) { | |
return t; | |
} | |
static | |
BOOST_UBLAS_INLINE | |
real_type type_abs (const_reference t) { | |
return boost_numeric_ublas_abs (t); | |
} | |
static | |
BOOST_UBLAS_INLINE | |
value_type type_sqrt (const_reference t) { | |
// force a type conversion back to value_type for intgral types | |
return value_type (boost_numeric_ublas_sqrt (t)); | |
} | |
static | |
BOOST_UBLAS_INLINE | |
real_type norm_1 (const_reference t) { | |
return self_type::type_abs (t); | |
} | |
static | |
BOOST_UBLAS_INLINE | |
real_type norm_2 (const_reference t) { | |
return self_type::type_abs (t); | |
} | |
static | |
BOOST_UBLAS_INLINE | |
real_type norm_inf (const_reference t) { | |
return self_type::type_abs (t); | |
} | |
static | |
BOOST_UBLAS_INLINE | |
bool equals (const_reference t1, const_reference t2) { | |
return self_type::norm_inf (t1 - t2) < BOOST_UBLAS_TYPE_CHECK_EPSILON * | |
(std::max) ((std::max) (self_type::norm_inf (t1), | |
self_type::norm_inf (t2)), | |
BOOST_UBLAS_TYPE_CHECK_MIN); | |
} | |
}; | |
// Define default type traits, assume T is a scalar type | |
template<class T> | |
struct type_traits : scalar_traits <T> { | |
typedef type_traits<T> self_type; | |
typedef T value_type; | |
typedef const T &const_reference; | |
typedef T &reference; | |
typedef T real_type; | |
typedef real_type precision_type; | |
static const unsigned multiplies_complexity = 1; | |
}; | |
// Define real type traits | |
template<> | |
struct type_traits<float> : scalar_traits<float> { | |
typedef type_traits<float> self_type; | |
typedef float value_type; | |
typedef const value_type &const_reference; | |
typedef value_type &reference; | |
typedef value_type real_type; | |
typedef double precision_type; | |
}; | |
template<> | |
struct type_traits<double> : scalar_traits<double> { | |
typedef type_traits<double> self_type; | |
typedef double value_type; | |
typedef const value_type &const_reference; | |
typedef value_type &reference; | |
typedef value_type real_type; | |
typedef long double precision_type; | |
}; | |
template<> | |
struct type_traits<long double> : scalar_traits<long double> { | |
typedef type_traits<long double> self_type; | |
typedef long double value_type; | |
typedef const value_type &const_reference; | |
typedef value_type &reference; | |
typedef value_type real_type; | |
typedef value_type precision_type; | |
}; | |
// Define properties for a generic complex type | |
template<class T> | |
struct complex_traits { | |
typedef complex_traits<T> self_type; | |
typedef T value_type; | |
typedef const T &const_reference; | |
typedef T &reference; | |
typedef typename T::value_type real_type; | |
typedef real_type precision_type; // we do not know what type has more precision then the real_type | |
static const unsigned plus_complexity = 2; | |
static const unsigned multiplies_complexity = 6; | |
static | |
BOOST_UBLAS_INLINE | |
real_type real (const_reference t) { | |
return std::real (t); | |
} | |
static | |
BOOST_UBLAS_INLINE | |
real_type imag (const_reference t) { | |
return std::imag (t); | |
} | |
static | |
BOOST_UBLAS_INLINE | |
value_type conj (const_reference t) { | |
return std::conj (t); | |
} | |
static | |
BOOST_UBLAS_INLINE | |
real_type type_abs (const_reference t) { | |
return abs (t); | |
} | |
static | |
BOOST_UBLAS_INLINE | |
value_type type_sqrt (const_reference t) { | |
return sqrt (t); | |
} | |
static | |
BOOST_UBLAS_INLINE | |
real_type norm_1 (const_reference t) { | |
return self_type::type_abs (t); | |
// original computation has been replaced because a complex number should behave like a scalar type | |
// return type_traits<real_type>::type_abs (self_type::real (t)) + | |
// type_traits<real_type>::type_abs (self_type::imag (t)); | |
} | |
static | |
BOOST_UBLAS_INLINE | |
real_type norm_2 (const_reference t) { | |
return self_type::type_abs (t); | |
} | |
static | |
BOOST_UBLAS_INLINE | |
real_type norm_inf (const_reference t) { | |
return self_type::type_abs (t); | |
// original computation has been replaced because a complex number should behave like a scalar type | |
// return (std::max) (type_traits<real_type>::type_abs (self_type::real (t)), | |
// type_traits<real_type>::type_abs (self_type::imag (t))); | |
} | |
static | |
BOOST_UBLAS_INLINE | |
bool equals (const_reference t1, const_reference t2) { | |
return self_type::norm_inf (t1 - t2) < BOOST_UBLAS_TYPE_CHECK_EPSILON * | |
(std::max) ((std::max) (self_type::norm_inf (t1), | |
self_type::norm_inf (t2)), | |
BOOST_UBLAS_TYPE_CHECK_MIN); | |
} | |
}; | |
// Define complex type traits | |
template<> | |
struct type_traits<std::complex<float> > : complex_traits<std::complex<float> >{ | |
typedef type_traits<std::complex<float> > self_type; | |
typedef std::complex<float> value_type; | |
typedef const value_type &const_reference; | |
typedef value_type &reference; | |
typedef float real_type; | |
typedef std::complex<double> precision_type; | |
}; | |
template<> | |
struct type_traits<std::complex<double> > : complex_traits<std::complex<double> >{ | |
typedef type_traits<std::complex<double> > self_type; | |
typedef std::complex<double> value_type; | |
typedef const value_type &const_reference; | |
typedef value_type &reference; | |
typedef double real_type; | |
typedef std::complex<long double> precision_type; | |
}; | |
template<> | |
struct type_traits<std::complex<long double> > : complex_traits<std::complex<long double> > { | |
typedef type_traits<std::complex<long double> > self_type; | |
typedef std::complex<long double> value_type; | |
typedef const value_type &const_reference; | |
typedef value_type &reference; | |
typedef long double real_type; | |
typedef value_type precision_type; | |
}; | |
#ifdef BOOST_UBLAS_USE_INTERVAL | |
// Define scalar interval type traits | |
template<> | |
struct type_traits<boost::numeric::interval<float> > : scalar_traits<boost::numeric::interval<float> > { | |
typedef type_traits<boost::numeric::interval<float> > self_type; | |
typedef boost::numeric::interval<float> value_type; | |
typedef const value_type &const_reference; | |
typedef value_type &reference; | |
typedef value_type real_type; | |
typedef boost::numeric::interval<double> precision_type; | |
}; | |
template<> | |
struct type_traits<boost::numeric::interval<double> > : scalar_traits<boost::numeric::interval<double> > { | |
typedef type_traits<boost::numeric::interval<double> > self_type; | |
typedef boost::numeric::interval<double> value_type; | |
typedef const value_type &const_reference; | |
typedef value_type &reference; | |
typedef value_type real_type; | |
typedef boost::numeric::interval<long double> precision_type; | |
}; | |
template<> | |
struct type_traits<boost::numeric::interval<long double> > : scalar_traits<boost::numeric::interval<long double> > { | |
typedef type_traits<boost::numeric::interval<long double> > self_type; | |
typedef boost::numeric::interval<long double> value_type; | |
typedef const value_type &const_reference; | |
typedef value_type &reference; | |
typedef value_type real_type; | |
typedef value_type precision_type; | |
}; | |
#endif | |
// Storage tags -- hierarchical definition of storage characteristics | |
struct unknown_storage_tag {}; | |
struct sparse_proxy_tag: public unknown_storage_tag {}; | |
struct sparse_tag: public sparse_proxy_tag {}; | |
struct packed_proxy_tag: public sparse_proxy_tag {}; | |
struct packed_tag: public packed_proxy_tag {}; | |
struct dense_proxy_tag: public packed_proxy_tag {}; | |
struct dense_tag: public dense_proxy_tag {}; | |
template<class S1, class S2> | |
struct storage_restrict_traits { | |
typedef S1 storage_category; | |
}; | |
template<> | |
struct storage_restrict_traits<sparse_tag, dense_proxy_tag> { | |
typedef sparse_proxy_tag storage_category; | |
}; | |
template<> | |
struct storage_restrict_traits<sparse_tag, packed_proxy_tag> { | |
typedef sparse_proxy_tag storage_category; | |
}; | |
template<> | |
struct storage_restrict_traits<sparse_tag, sparse_proxy_tag> { | |
typedef sparse_proxy_tag storage_category; | |
}; | |
template<> | |
struct storage_restrict_traits<packed_tag, dense_proxy_tag> { | |
typedef packed_proxy_tag storage_category; | |
}; | |
template<> | |
struct storage_restrict_traits<packed_tag, packed_proxy_tag> { | |
typedef packed_proxy_tag storage_category; | |
}; | |
template<> | |
struct storage_restrict_traits<packed_tag, sparse_proxy_tag> { | |
typedef sparse_proxy_tag storage_category; | |
}; | |
template<> | |
struct storage_restrict_traits<packed_proxy_tag, sparse_proxy_tag> { | |
typedef sparse_proxy_tag storage_category; | |
}; | |
template<> | |
struct storage_restrict_traits<dense_tag, dense_proxy_tag> { | |
typedef dense_proxy_tag storage_category; | |
}; | |
template<> | |
struct storage_restrict_traits<dense_tag, packed_proxy_tag> { | |
typedef packed_proxy_tag storage_category; | |
}; | |
template<> | |
struct storage_restrict_traits<dense_tag, sparse_proxy_tag> { | |
typedef sparse_proxy_tag storage_category; | |
}; | |
template<> | |
struct storage_restrict_traits<dense_proxy_tag, packed_proxy_tag> { | |
typedef packed_proxy_tag storage_category; | |
}; | |
template<> | |
struct storage_restrict_traits<dense_proxy_tag, sparse_proxy_tag> { | |
typedef sparse_proxy_tag storage_category; | |
}; | |
// Iterator tags -- hierarchical definition of storage characteristics | |
struct sparse_bidirectional_iterator_tag : public std::bidirectional_iterator_tag {}; | |
struct packed_random_access_iterator_tag : public std::random_access_iterator_tag {}; | |
struct dense_random_access_iterator_tag : public packed_random_access_iterator_tag {}; | |
// Thanks to Kresimir Fresl for convincing Comeau with iterator_base_traits ;-) | |
template<class IC> | |
struct iterator_base_traits {}; | |
template<> | |
struct iterator_base_traits<std::forward_iterator_tag> { | |
template<class I, class T> | |
struct iterator_base { | |
typedef forward_iterator_base<std::forward_iterator_tag, I, T> type; | |
}; | |
}; | |
template<> | |
struct iterator_base_traits<std::bidirectional_iterator_tag> { | |
template<class I, class T> | |
struct iterator_base { | |
typedef bidirectional_iterator_base<std::bidirectional_iterator_tag, I, T> type; | |
}; | |
}; | |
template<> | |
struct iterator_base_traits<sparse_bidirectional_iterator_tag> { | |
template<class I, class T> | |
struct iterator_base { | |
typedef bidirectional_iterator_base<sparse_bidirectional_iterator_tag, I, T> type; | |
}; | |
}; | |
template<> | |
struct iterator_base_traits<std::random_access_iterator_tag> { | |
template<class I, class T> | |
struct iterator_base { | |
typedef random_access_iterator_base<std::random_access_iterator_tag, I, T> type; | |
}; | |
}; | |
template<> | |
struct iterator_base_traits<packed_random_access_iterator_tag> { | |
template<class I, class T> | |
struct iterator_base { | |
typedef random_access_iterator_base<packed_random_access_iterator_tag, I, T> type; | |
}; | |
}; | |
template<> | |
struct iterator_base_traits<dense_random_access_iterator_tag> { | |
template<class I, class T> | |
struct iterator_base { | |
typedef random_access_iterator_base<dense_random_access_iterator_tag, I, T> type; | |
}; | |
}; | |
template<class I1, class I2> | |
struct iterator_restrict_traits { | |
typedef I1 iterator_category; | |
}; | |
template<> | |
struct iterator_restrict_traits<packed_random_access_iterator_tag, sparse_bidirectional_iterator_tag> { | |
typedef sparse_bidirectional_iterator_tag iterator_category; | |
}; | |
template<> | |
struct iterator_restrict_traits<sparse_bidirectional_iterator_tag, packed_random_access_iterator_tag> { | |
typedef sparse_bidirectional_iterator_tag iterator_category; | |
}; | |
template<> | |
struct iterator_restrict_traits<dense_random_access_iterator_tag, sparse_bidirectional_iterator_tag> { | |
typedef sparse_bidirectional_iterator_tag iterator_category; | |
}; | |
template<> | |
struct iterator_restrict_traits<sparse_bidirectional_iterator_tag, dense_random_access_iterator_tag> { | |
typedef sparse_bidirectional_iterator_tag iterator_category; | |
}; | |
template<> | |
struct iterator_restrict_traits<dense_random_access_iterator_tag, packed_random_access_iterator_tag> { | |
typedef packed_random_access_iterator_tag iterator_category; | |
}; | |
template<> | |
struct iterator_restrict_traits<packed_random_access_iterator_tag, dense_random_access_iterator_tag> { | |
typedef packed_random_access_iterator_tag iterator_category; | |
}; | |
template<class I> | |
BOOST_UBLAS_INLINE | |
void increment (I &it, const I &it_end, typename I::difference_type compare, packed_random_access_iterator_tag) { | |
it += (std::min) (compare, it_end - it); | |
} | |
template<class I> | |
BOOST_UBLAS_INLINE | |
void increment (I &it, const I &/* it_end */, typename I::difference_type /* compare */, sparse_bidirectional_iterator_tag) { | |
++ it; | |
} | |
template<class I> | |
BOOST_UBLAS_INLINE | |
void increment (I &it, const I &it_end, typename I::difference_type compare) { | |
increment (it, it_end, compare, typename I::iterator_category ()); | |
} | |
template<class I> | |
BOOST_UBLAS_INLINE | |
void increment (I &it, const I &it_end) { | |
#if BOOST_UBLAS_TYPE_CHECK | |
I cit (it); | |
while (cit != it_end) { | |
BOOST_UBLAS_CHECK (*cit == typename I::value_type/*zero*/(), internal_logic ()); | |
++ cit; | |
} | |
#endif | |
it = it_end; | |
} | |
namespace detail { | |
// specialisation which define whether a type has a trivial constructor | |
// or not. This is used by array types. | |
template<typename T> | |
struct has_trivial_constructor : public boost::has_trivial_constructor<T> {}; | |
template<typename T> | |
struct has_trivial_destructor : public boost::has_trivial_destructor<T> {}; | |
template<typename FLT> | |
struct has_trivial_constructor<std::complex<FLT> > : public boost::true_type {}; | |
template<typename FLT> | |
struct has_trivial_destructor<std::complex<FLT> > : public boost::true_type {}; | |
} | |
/** \brief Traits class to extract type information from a constant matrix or vector CONTAINER. | |
* | |
*/ | |
template < class E > | |
struct container_view_traits { | |
/// type of indices | |
typedef typename E::size_type size_type; | |
/// type of differences of indices | |
typedef typename E::difference_type difference_type; | |
/// storage category: \c unknown_storage_tag, \c dense_tag, \c packed_tag, ... | |
typedef typename E::storage_category storage_category; | |
/// type of elements | |
typedef typename E::value_type value_type; | |
/// const reference to an element | |
typedef typename E::const_reference const_reference; | |
/// type used in expressions to mark a reference to this class (usually a const container_reference<const E> or the class itself) | |
typedef typename E::const_closure_type const_closure_type; | |
}; | |
/** \brief Traits class to extract additional type information from a mutable matrix or vector CONTAINER. | |
* | |
*/ | |
template < class E > | |
struct mutable_container_traits { | |
/// reference to an element | |
typedef typename E::reference reference; | |
/// type used in expressions to mark a reference to this class (usually a container_reference<E> or the class itself) | |
typedef typename E::closure_type closure_type; | |
}; | |
/** \brief Traits class to extract type information from a matrix or vector CONTAINER. | |
* | |
*/ | |
template < class E > | |
struct container_traits | |
: container_view_traits<E>, mutable_container_traits<E> { | |
}; | |
/** \brief Traits class to extract type information from a constant MATRIX. | |
* | |
*/ | |
template < class MATRIX > | |
struct matrix_view_traits : container_view_traits <MATRIX> { | |
/// orientation of the matrix, either \c row_major_tag, \c column_major_tag or \c unknown_orientation_tag | |
typedef typename MATRIX::orientation_category orientation_category; | |
/// row iterator for the matrix | |
typedef typename MATRIX::const_iterator1 const_iterator1; | |
/// column iterator for the matrix | |
typedef typename MATRIX::const_iterator2 const_iterator2; | |
}; | |
/** \brief Traits class to extract additional type information from a mutable MATRIX. | |
* | |
*/ | |
template < class MATRIX > | |
struct mutable_matrix_traits | |
: mutable_container_traits <MATRIX> { | |
/// row iterator for the matrix | |
typedef typename MATRIX::iterator1 iterator1; | |
/// column iterator for the matrix | |
typedef typename MATRIX::iterator2 iterator2; | |
}; | |
/** \brief Traits class to extract type information from a MATRIX. | |
* | |
*/ | |
template < class MATRIX > | |
struct matrix_traits | |
: matrix_view_traits <MATRIX>, mutable_matrix_traits <MATRIX> { | |
}; | |
/** \brief Traits class to extract type information from a VECTOR. | |
* | |
*/ | |
template < class VECTOR > | |
struct vector_view_traits : container_view_traits <VECTOR> { | |
/// iterator for the VECTOR | |
typedef typename VECTOR::const_iterator const_iterator; | |
/// iterator pointing to the first element | |
static | |
const_iterator begin(const VECTOR & v) { | |
return v.begin(); | |
} | |
/// iterator pointing behind the last element | |
static | |
const_iterator end(const VECTOR & v) { | |
return v.end(); | |
} | |
}; | |
/** \brief Traits class to extract type information from a VECTOR. | |
* | |
*/ | |
template < class VECTOR > | |
struct mutable_vector_traits : mutable_container_traits <VECTOR> { | |
/// iterator for the VECTOR | |
typedef typename VECTOR::iterator iterator; | |
/// iterator pointing to the first element | |
static | |
iterator begin(VECTOR & v) { | |
return v.begin(); | |
} | |
/// iterator pointing behind the last element | |
static | |
iterator end(VECTOR & v) { | |
return v.end(); | |
} | |
}; | |
/** \brief Traits class to extract type information from a VECTOR. | |
* | |
*/ | |
template < class VECTOR > | |
struct vector_traits | |
: vector_view_traits <VECTOR>, mutable_vector_traits <VECTOR> { | |
}; | |
// Note: specializations for T[N] and T[M][N] have been moved to traits/c_array.hpp | |
}}} | |
#endif |