diff options
Diffstat (limited to 'boost/numeric/odeint/util/ublas_wrapper.hpp')
| -rw-r--r-- | boost/numeric/odeint/util/ublas_wrapper.hpp | 297 |
1 files changed, 297 insertions, 0 deletions
diff --git a/boost/numeric/odeint/util/ublas_wrapper.hpp b/boost/numeric/odeint/util/ublas_wrapper.hpp new file mode 100644 index 0000000000..c8facfc46b --- /dev/null +++ b/boost/numeric/odeint/util/ublas_wrapper.hpp @@ -0,0 +1,297 @@ +/* + [auto_generated] + boost/numeric/odeint/util/ublas_wrapper.hpp + + [begin_description] + Resizing for ublas::vector and ublas::matrix + [end_description] + + Copyright 2011-2013 Mario Mulansky + Copyright 2011-2013 Karsten Ahnert + + 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 BOOST_NUMERIC_ODEINT_UTIL_UBLAS_WRAPPER_HPP_INCLUDED +#define BOOST_NUMERIC_ODEINT_UTIL_UBLAS_WRAPPER_HPP_INCLUDED + + +#include <boost/type_traits/integral_constant.hpp> +#include <boost/numeric/ublas/vector.hpp> +#include <boost/numeric/ublas/matrix.hpp> +#include <boost/numeric/ublas/lu.hpp> +#include <boost/numeric/ublas/vector_expression.hpp> +#include <boost/numeric/ublas/matrix_expression.hpp> + +#include <boost/numeric/odeint/algebra/vector_space_algebra.hpp> +#include <boost/numeric/odeint/algebra/default_operations.hpp> + +#include <boost/numeric/odeint/util/is_resizeable.hpp> +#include <boost/numeric/odeint/util/state_wrapper.hpp> + + +/* extend ublas by a few operations */ + +/* map norm_inf onto reduce( v , default_operations::maximum ) */ +namespace boost { namespace numeric { namespace odeint { + + template< typename T , typename A > + struct vector_space_norm_inf< boost::numeric::ublas::vector<T,A> > + { + typedef T result_type; + + result_type operator()( const boost::numeric::ublas::vector<T,A> &x ) const + { + return boost::numeric::ublas::norm_inf( x ); + } + }; + + + template< class T , class L , class A > + struct vector_space_norm_inf< boost::numeric::ublas::matrix<T,L,A> > + { + typedef T result_type; + + result_type operator()( const boost::numeric::ublas::matrix<T,L,A> &x ) const + { + return boost::numeric::ublas::norm_inf( x ); + } + }; +} } } + +/* additional operations: + * abs( v ) + * v / w + * a + v + */ +namespace boost { namespace numeric { namespace ublas { + + + // elementwise abs - calculates absolute values of the elements + template<class T> + struct scalar_abs: public scalar_unary_functor<T> { + typedef typename scalar_unary_functor<T>::value_type value_type; + typedef typename scalar_unary_functor<T>::argument_type argument_type; + typedef typename scalar_unary_functor<T>::result_type result_type; + + static BOOST_UBLAS_INLINE + result_type apply (argument_type t) { + using std::abs; + return abs (t); + } + }; + + + // (abs v) [i] = abs (v [i]) + template<class E> + BOOST_UBLAS_INLINE + typename vector_unary_traits<E, scalar_abs<typename E::value_type> >::result_type + abs (const vector_expression<E> &e) { + typedef typename vector_unary_traits<E, scalar_abs<typename E::value_type> >::expression_type expression_type; + return expression_type (e ()); + } + + // (abs m) [i] = abs (m [i]) + template<class E> + BOOST_UBLAS_INLINE + typename matrix_unary1_traits<E, scalar_abs<typename E::value_type> >::result_type + abs (const matrix_expression<E> &e) { + typedef typename matrix_unary1_traits<E, scalar_abs<typename E::value_type> >::expression_type expression_type; + return expression_type (e ()); + } + + + // elementwise division (v1 / v2) [i] = v1 [i] / v2 [i] + template<class E1, class E2> + BOOST_UBLAS_INLINE + typename vector_binary_traits<E1, E2, scalar_divides<typename E1::value_type, + typename E2::value_type> >::result_type + operator / (const vector_expression<E1> &e1, + const vector_expression<E2> &e2) { + typedef typename vector_binary_traits<E1, E2, scalar_divides<typename E1::value_type, + typename E2::value_type> >::expression_type expression_type; + return expression_type (e1 (), e2 ()); + } + + + // elementwise division (m1 / m2) [i] = m1 [i] / m2 [i] + template<class E1, class E2> + BOOST_UBLAS_INLINE + typename matrix_binary_traits<E1, E2, scalar_divides<typename E1::value_type, + typename E2::value_type> >::result_type + operator / (const matrix_expression<E1> &e1, + const matrix_expression<E2> &e2) { + typedef typename matrix_binary_traits<E1, E2, scalar_divides<typename E1::value_type, + typename E2::value_type> >::expression_type expression_type; + return expression_type (e1 (), e2 ()); + } + + // addition with scalar + // (t + v) [i] = t + v [i] + template<class T1, class E2> + BOOST_UBLAS_INLINE + typename enable_if< is_convertible<T1, typename E2::value_type >, + typename vector_binary_scalar1_traits<const T1, E2, scalar_plus<T1, typename E2::value_type> >::result_type + >::type + operator + (const T1 &e1, + const vector_expression<E2> &e2) { + typedef typename vector_binary_scalar1_traits<const T1, E2, scalar_plus<T1, typename E2::value_type> >::expression_type expression_type; + return expression_type (e1, e2 ()); + } + + // addition with scalar + // (t + m) [i] = t + m [i] + template<class T1, class E2> + BOOST_UBLAS_INLINE + typename enable_if< is_convertible<T1, typename E2::value_type >, + typename matrix_binary_scalar1_traits<const T1, E2, scalar_plus<T1, typename E2::value_type> >::result_type + >::type + operator + (const T1 &e1, + const matrix_expression<E2> &e2) { + typedef typename matrix_binary_scalar1_traits<const T1, E2, scalar_plus<T1, typename E2::value_type> >::expression_type expression_type; + return expression_type (e1, e2 ()); + } + +} } } + + + + +/* add resize functionality */ +namespace boost { +namespace numeric { +namespace odeint { + +/* + * resizeable specialization for boost::numeric::ublas::vector + */ +template< class T , class A > +struct is_resizeable< boost::numeric::ublas::vector< T , A > > +{ + typedef boost::true_type type; + const static bool value = type::value; +}; + + +/* + * resizeable specialization for boost::numeric::ublas::matrix + */ +template< class T , class L , class A > +struct is_resizeable< boost::numeric::ublas::matrix< T , L , A > > +{ + typedef boost::true_type type; + const static bool value = type::value; +}; + + +/* + * resizeable specialization for boost::numeric::ublas::permutation_matrix + */ +template< class T , class A > +struct is_resizeable< boost::numeric::ublas::permutation_matrix< T , A > > +{ + typedef boost::true_type type; + const static bool value = type::value; +}; + + +// specialization for ublas::matrix +// same size and resize specialization for matrix-matrix resizing +template< class T , class L , class A , class T2 , class L2 , class A2 > +struct same_size_impl< boost::numeric::ublas::matrix< T , L , A > , boost::numeric::ublas::matrix< T2 , L2 , A2 > > +{ + static bool same_size( const boost::numeric::ublas::matrix< T , L , A > &m1 , + const boost::numeric::ublas::matrix< T2 , L2 , A2 > &m2 ) + { + return ( ( m1.size1() == m2.size1() ) && ( m1.size2() == m2.size2() ) ); + } +}; + +template< class T , class L , class A , class T2 , class L2 , class A2 > +struct resize_impl< boost::numeric::ublas::matrix< T , L , A > , boost::numeric::ublas::matrix< T2 , L2 , A2 > > +{ + static void resize( boost::numeric::ublas::matrix< T , L , A > &m1 , + const boost::numeric::ublas::matrix< T2 , L2 , A2 > &m2 ) + { + m1.resize( m2.size1() , m2.size2() ); + } +}; + + + +// same size and resize specialization for matrix-vector resizing +template< class T , class L , class A , class T_V , class A_V > +struct same_size_impl< boost::numeric::ublas::matrix< T , L , A > , boost::numeric::ublas::vector< T_V , A_V > > +{ + static bool same_size( const boost::numeric::ublas::matrix< T , L , A > &m , + const boost::numeric::ublas::vector< T_V , A_V > &v ) + { + return ( ( m.size1() == v.size() ) && ( m.size2() == v.size() ) ); + } +}; + +template< class T , class L , class A , class T_V , class A_V > +struct resize_impl< boost::numeric::ublas::matrix< T , L , A > , boost::numeric::ublas::vector< T_V , A_V > > +{ + static void resize( boost::numeric::ublas::matrix< T , L , A > &m , + const boost::numeric::ublas::vector< T_V , A_V > &v ) + { + m.resize( v.size() , v.size() ); + } +}; + + + +// specialization for ublas::permutation_matrix +// same size and resize specialization for matrix-vector resizing +template< class T , class A , class T_V , class A_V > +struct same_size_impl< boost::numeric::ublas::permutation_matrix< T , A > , + boost::numeric::ublas::vector< T_V , A_V > > +{ + static bool same_size( const boost::numeric::ublas::permutation_matrix< T , A > &m , + const boost::numeric::ublas::vector< T_V , A_V > &v ) + { + return ( m.size() == v.size() ); // && ( m.size2() == v.size() ) ); + } +}; + +template< class T , class A , class T_V , class A_V > +struct resize_impl< boost::numeric::ublas::vector< T_V , A_V > , + boost::numeric::ublas::permutation_matrix< T , A > > +{ + static void resize( const boost::numeric::ublas::vector< T_V , A_V > &v, + boost::numeric::ublas::permutation_matrix< T , A > &m ) + { + m.resize( v.size() , v.size() ); + } +}; + + + + + + + +template< class T , class A > +struct state_wrapper< boost::numeric::ublas::permutation_matrix< T , A > > // with resizing +{ + typedef boost::numeric::ublas::permutation_matrix< T , A > state_type; + typedef state_wrapper< state_type > state_wrapper_type; + + state_type m_v; + + state_wrapper() : m_v( 1 ) // permutation matrix constructor requires a size, choose 1 as default + { } + +}; + + + + +} } } + + +#endif // BOOST_NUMERIC_ODEINT_UTIL_UBLAS_WRAPPER_HPP_INCLUDED |