Nabble - Boost - uBLAS

Williams Grand Prix Engineering Limited. Registered in England no. 1297497. VAT no. GB292559325. This email is confidential. If you are not the addressee, please contact us by reply.

[diff]
diff -r c6dde043ee33 boost/numeric/ublas/traits.hpp

--- a/boost/numeric/ublas/traits.hpp	Wed Nov 18 18:41:53 2009 -0500

+++ b/boost/numeric/ublas/traits.hpp	Thu Nov 19 15:17:42 2009 -0500

@@ -23,6 +23,11 @@

 

 #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 {

@@ -40,6 +45,87 @@

 

 namespace boost { namespace numeric { namespace ublas {

 

+      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);

+      }

+

+

 


[vector_generator.cpp]
#include <boost/numeric/ublas/vector.hpp>

#include <boost/numeric/ublas/vector_expression.hpp>

#include <boost/numeric/ublas/io.hpp>


using namespace boost::numeric::ublas;


template<class F, class ALLOC = std::allocator<typename F::result_type> > class vector_generator; // Forward declaration


template<class F, class ALLOC>

class vector_generator:

        public vector_container< vector_generator<F, ALLOC> > {

                

        typedef F functor_type;

        typedef vector_generator<F, ALLOC> self_type;

public:

        typedef typename F::result_type value_type;

        typedef typename ALLOC::size_type size_type;

        typedef typename ALLOC::difference_type difference_type;

        typedef const value_type& const_reference;

        typedef value_type& reference;

        typedef sparse_tag storage_category;

        typedef const value_type* const_pointer;

        typedef const vector_reference<const self_type> const_closure_type;

public:

        vector_generator( functor_type functor, size_type size = 0 ):

                size_( size ), functor_( functor ) {

        }


        size_type size() const {

                return size_;

        }

        void resize( size_type size, bool /*preserve*/ = true ) {

                size_ = size;

        }

        

        const value_type operator()( size_type i ) const {

                return functor_( i );

        }

        //reference operator()(size_type i); no non-const access

        const value_type operator[]( size_type i ) const {

                return functor_( i );

        }

        //reference operator[](size_type i); no non-const access


        //Iterators

public:

        class const_iterator;


        const_iterator find( size_type i ) const {

                return const_iterator( (*this), i );

        }

        

        class const_iterator:

                public container_const_reference< self_type >,

                public bidirectional_iterator_base<sparse_bidirectional_iterator_tag, const_iterator, value_type> {

        public:

                typedef typename self_type::difference_type difference_type;

                typedef typename self_type::value_type value_type;

                typedef typename self_type::size_type size_type;

                typedef typename self_type::const_reference reference;

                typedef typename self_type::const_pointer pointer;


                // Construction and destruction

                const_iterator( size_type i = 0 ):

                        container_const_reference<self_type>(), it_(i) {}

                const_iterator(const self_type &v, size_type i ):

                        container_const_reference<self_type>(v), it_(i) {}


                const_iterator &operator++() {

                        ++it_;

                        return *this;

                }

                const_iterator &operator--() {

                        --it_;

                        return *this;

                }

                const_iterator &operator += (difference_type n) {

                        it_ += n;

                        return *this;

                }

                const_iterator &operator -= (difference_type n) {

                        it_ -= n;

                        return *this;

                }

                value_type operator*() const {

                        BOOST_UBLAS_CHECK (it_ >= (*this) ().begin ().it_ && it_ < (*this) ().end ().it_, bad_index ());

                        return (*this)()( it_ );

                }

                value_type operator[](difference_type n) const {

                        return *(it_ + n);

                }

                size_type index() const {

                        BOOST_UBLAS_CHECK (it_ >= (*this)().begin ().it_ && it_ < (*this)().end ().it_, bad_index ());

                        return it_;

                }

                bool operator == (const const_iterator &it) const {

                        BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());

                        return it_ == it.it_;

                }

                bool operator < (const const_iterator &it) const {

                        BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());

                        return it_ < it.it_;

                }

        private:

                size_type it_;

        };


        typedef const_iterator iterator;

        typedef reverse_iterator_base<const_iterator> const_reverse_iterator;

        const_iterator begin() const {

                return find( 0 );

        }

        const_iterator end() const {

                return find( size() );

        }

        const_reverse_iterator rbegin() const {

                return const_reverse_iterator( end() );

        }

        const_reverse_iterator rend() const {

                return const_reverse_iterator( begin() );

        }

        

private:

        size_type    size_;

        functor_type functor_;

};


struct tfun {

        typedef double result_type;


        result_type operator() ( unsigned int i ) const {

                return result_type(i);

        }

};


int main() {

        vector_generator<tfun> vg( tfun() ,12);

        vector<double> vec( vg );

        std::cout << vg*2 << std::endl;

        std::cout << vec << std::endl;

        std::cout << inner_prod(vg,vg) << std::endl;

        return 0;

}



[test11.cpp.diff]
diff -r dcee1338df33 libs/numeric/ublas/test/test11.cpp

--- a/libs/numeric/ublas/test/test11.cpp	Tue Sep 29 15:01:07 2009 -0400

+++ b/libs/numeric/ublas/test/test11.cpp	Fri Oct 09 11:41:57 2009 -0400

@@ -92,7 +92,10 @@

         v2 = v1 * value_type (1.);

         std::cout << "v1 * 1. = " << v2 << std::endl;

         v2 = v1 * t;

-        std::cout << "v1 * N = " << v2 << std::endl;

+        std::cout << "v1 * value_type(N) = " << v2 << std::endl;

+	// test interop with integer

+	v2 = v1 * N;

+	std::cout << "v1 * N = " << v2 << std::endl;

 

         // Some assignments

         initialize_vector (v1);

@@ -108,6 +111,9 @@

         v1 *= value_type (1.);

         std::cout << "v1 *= 1. = " << v1 << std::endl;

         v1 *= t;

+        std::cout << "v1 *= value_type(N) = " << v1 << std::endl;

+	// test interop with integer

+	v1 *= N;

         std::cout << "v1 *= N = " << v1 << std::endl;

 

         // Unary vector operations resulting in a scalar



[traits.diff]
diff -r dcee1338df33 boost/numeric/ublas/traits.hpp

--- a/boost/numeric/ublas/traits.hpp	Tue Sep 29 15:01:07 2009 -0400

+++ b/boost/numeric/ublas/traits.hpp	Fri Oct 09 08:50:15 2009 -0400

@@ -26,6 +26,8 @@

 #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 {

@@ -43,43 +45,83 @@

 

 namespace boost { namespace numeric { namespace ublas {

 

-      template<typename R> 

-      typename boost::enable_if<boost::is_float<R>, std::complex<R> >::type inline operator+ (int in1, std::complex<R> const& 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 boost::enable_if<boost::is_float<R>, std::complex<R> >::type inline operator+ (std::complex<R> const& in1, int 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 boost::enable_if<boost::is_float<R>, std::complex<R> >::type  inline operator- (int in1, std::complex<R> const& 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 boost::enable_if<boost::is_float<R>, std::complex<R> >::type  inline operator- (std::complex<R> const& in1, int 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 boost::enable_if<boost::is_float<R>, std::complex<R> >::type  inline operator* (int in1, std::complex<R> const& 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 boost::enable_if<boost::is_float<R>, std::complex<R> >::type inline operator* (std::complex<R> const& in1, int 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 boost::enable_if<boost::is_float<R>, std::complex<R> >::type  inline operator/ (int in1, std::complex<R> const& 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 boost::enable_if<boost::is_float<R>, std::complex<R> >::type  inline operator/ (std::complex<R> const& in1, int 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);

       }

 




Nabble - Boost - uBLAS

Re: [bindings] New traits system

[bindings] New traits system

Re: thread safety of matrix multiplication

Re: thread safety of matrix multiplication

thread safety of matrix multiplication

Matrix initialization in a constructor

Re: now that 1.41.0 is out...

now that 1.41.0 is out...

Re: [newbie] submatrix and rest of a matrix

Re: [newbie] submatrix and rest of a matrix

Re: [newbie] submatrix and rest of a matrix

[newbie] submatrix and rest of a matrix

Re: vector generator

Re: vector generator

Re: prod(trans(M),M) performance?

Re: Changes in 1.41

Re: Changes in 1.41

Changes in 1.41

[bindings][UMFPack]A bug may be found in UMFPack Bindings

prod(trans(M),M) performance?

vector generator

Re: LU decomposition: how can I get a unique solution?

Re: LU decomposition: how can I get a unique solution?

LU decomposition: how can I get a unique solution?

[bindings][blas] Included CBLAS support

How to implement functions that take matrix_expressions as arguments?

How to implement functions that take matrix_expressions as arguments?

Re: [bindings] lapack errors

Re: [bindings] lapack errors

Re: [feature request] new free functions for matrix/vector sizes

Re: Proposed change: use BOOST_TYPEOF

Re: enable complex @ int

Proposed change: use BOOST_TYPEOF

Re: enable complex @ int

Re: Problems with identity_matrix<> / lu_substitute()