boost/ublas
2
0
Fork 0
mirror of https://github.com/boostorg/ublas.git synced 2026-02-21 03:22:14 +00:00
Code Issues Projects Releases Wiki Activity

OLD_INIT syntax for nil_ static members

Browse Source 
[SVN r24903]
This commit is contained in:
Michael Stevens
2004-09-04 14:48:53 +00:00
parent b755a71c02
commit dc9e3f7bde
8 changed files with 208 additions and 127 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
include/boost/numeric/ublas/banded.hpp
View File

@@ -2036,7 +2036,11 @@ namespace boost { namespace numeric { namespace ublas {
};
template<class M>
typename banded_adaptor<M>::matrix_type banded_adaptor<M>::nil_;
typename banded_adaptor<M>::matrix_type banded_adaptor<M>::nil_
#ifdef BOOST_UBLAS_STATIC_OLD_INIT
= BOOST_UBLAS_TYPENAME banded_adaptor<M>::matrix_type ()
#endif
;
template<class M>
typename banded_adaptor<M>::const_value_type banded_adaptor<M>::zero_
#ifdef BOOST_UBLAS_STATIC_OLD_INIT

8
include/boost/numeric/ublas/hermitian.hpp
View File

@@ -2553,8 +2553,16 @@ namespace boost { namespace numeric { namespace ublas {
template<class M, class F>
typename hermitian_adaptor<M, F>::matrix_type hermitian_adaptor<M, F>::nil_;
#ifdef BOOST_UBLAS_STATIC_OLD_INIT
= BOOST_UBLAS_TYPENAME hermitian_adaptor<M, F>::matrix_type()
#endif
;
template<class M, class F>
typename hermitian_adaptor<M, F>::value_type hermitian_adaptor<M, F>::conj_;
#ifdef BOOST_UBLAS_STATIC_OLD_INIT
= BOOST_UBLAS_TYPENAME hermitian_adaptor<M, F>::value_type()
#endif
;
}}}

13
include/boost/numeric/ublas/matrix_expression.hpp
View File

@@ -335,7 +335,12 @@ namespace boost { namespace numeric { namespace ublas {
};
template<class E>
const typename matrix_const_reference<E>::expression_type matrix_const_reference<E>::nil_;
const typename matrix_const_reference<E>::expression_type matrix_const_reference<E>::nil_
#ifdef BOOST_UBLAS_STATIC_OLD_INIT
= BOOST_UBLAS_TYPENAME matrix_const_reference<E>::expression_type()
#endif
;
#endif
template<class E>
@@ -620,7 +625,11 @@ namespace boost { namespace numeric { namespace ublas {
};
template<class E>
typename matrix_reference<E>::expression_type matrix_reference<E>::nil_;
typename matrix_reference<E>::expression_type matrix_reference<E>::nil_
#ifdef BOOST_UBLAS_STATIC_OLD_INIT
= BOOST_UBLAS_TYPENAME matrix_reference<E>::expression_type()
#endif
;
template<class E1, class E2, class F>
class vector_matrix_binary:

202
include/boost/numeric/ublas/matrix_proxy.hpp
View File

@@ -133,62 +133,62 @@ namespace boost { namespace numeric { namespace ublas {
matrix_row &operator = (const matrix_row &mr) {
// FIXME: the rows could be differently sized.
// std::copy (mr.begin (), mr.end (), begin ());
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (mr));
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (mr));
return *this;
}
BOOST_UBLAS_INLINE
matrix_row &assign_temporary (matrix_row &mr) {
// FIXME: this is suboptimal.
// return *this = mr;
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, mr);
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, mr);
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_row &operator = (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (ae));
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (ae));
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_row &assign (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_row &operator += (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (*this + ae));
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (*this + ae));
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_row &plus_assign (const vector_expression<AE> &ae) {
vector_assign (scalar_plus_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
vector_assign (scalar_plus_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_row &operator -= (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (*this - ae));
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (*this - ae));
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_row &minus_assign (const vector_expression<AE> &ae) {
vector_assign (scalar_minus_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
vector_assign (scalar_minus_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
return *this;
}
template<class AT>
BOOST_UBLAS_INLINE
matrix_row &operator *= (const AT &at) {
vector_assign_scalar (scalar_multiplies_assign<typename iterator::reference, AT> (), *this, at);
vector_assign_scalar (scalar_multiplies_assign<BOOST_UBLAS_TYPENAME iterator::reference, AT> (), *this, at);
return *this;
}
template<class AT>
BOOST_UBLAS_INLINE
matrix_row &operator /= (const AT &at) {
vector_assign_scalar (scalar_divides_assign<typename iterator::reference, AT> (), *this, at);
vector_assign_scalar (scalar_divides_assign<BOOST_UBLAS_TYPENAME iterator::reference, AT> (), *this, at);
return *this;
}
@@ -513,7 +513,11 @@ namespace boost { namespace numeric { namespace ublas {
};
template<class M>
typename matrix_row<M>::matrix_type matrix_row<M>::nil_;
typename matrix_row<M>::matrix_type matrix_row<M>::nil_
#ifdef BOOST_UBLAS_STATIC_OLD_INIT
= BOOST_UBLAS_TYPENAME matrix_row<M>::matrix_type()
#endif
;
// Projections
template<class M>
@@ -642,62 +646,62 @@ namespace boost { namespace numeric { namespace ublas {
matrix_column &operator = (const matrix_column &mc) {
// FIXME: the columns could be differently sized.
// std::copy (mc.begin (), mc.end (), begin ());
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (mc));
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (mc));
return *this;
}
BOOST_UBLAS_INLINE
matrix_column &assign_temporary (matrix_column &mc) {
// FIXME: this is suboptimal.
// return *this = mc;
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, mc);
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, mc);
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_column &operator = (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (ae));
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (ae));
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_column &assign (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_column &operator += (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (*this + ae));
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (*this + ae));
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_column &plus_assign (const vector_expression<AE> &ae) {
vector_assign (scalar_plus_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
vector_assign (scalar_plus_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_column &operator -= (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (*this - ae));
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (*this - ae));
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_column &minus_assign (const vector_expression<AE> &ae) {
vector_assign (scalar_minus_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
vector_assign (scalar_minus_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
return *this;
}
template<class AT>
BOOST_UBLAS_INLINE
matrix_column &operator *= (const AT &at) {
vector_assign_scalar (scalar_multiplies_assign<typename iterator::reference, AT> (), *this, at);
vector_assign_scalar (scalar_multiplies_assign<BOOST_UBLAS_TYPENAME iterator::reference, AT> (), *this, at);
return *this;
}
template<class AT>
BOOST_UBLAS_INLINE
matrix_column &operator /= (const AT &at) {
vector_assign_scalar (scalar_divides_assign<typename iterator::reference, AT> (), *this, at);
vector_assign_scalar (scalar_divides_assign<BOOST_UBLAS_TYPENAME iterator::reference, AT> (), *this, at);
return *this;
}
@@ -1024,7 +1028,11 @@ namespace boost { namespace numeric { namespace ublas {
};
template<class M>
typename matrix_column<M>::matrix_type matrix_column<M>::nil_;
typename matrix_column<M>::matrix_type matrix_column<M>::nil_
#ifdef BOOST_UBLAS_STATIC_OLD_INIT
= BOOST_UBLAS_TYPENAME matrix_column<M>::matrix_type()
#endif
;
// Projections
template<class M>
@@ -1161,62 +1169,62 @@ namespace boost { namespace numeric { namespace ublas {
matrix_vector_range &operator = (const matrix_vector_range &mvr) {
// FIXME: the ranges could be differently sized.
// std::copy (mvr.begin (), mvr.end (), begin ());
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (mvr));
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (mvr));
return *this;
}
BOOST_UBLAS_INLINE
matrix_vector_range &assign_temporary (matrix_vector_range &mvr) {
// FIXME: this is suboptimal.
// return *this = mvr;
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, mvr);
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, mvr);
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_vector_range &operator = (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (ae));
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (ae));
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_vector_range &assign (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_vector_range &operator += (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (*this + ae));
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (*this + ae));
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_vector_range &plus_assign (const vector_expression<AE> &ae) {
vector_assign (scalar_plus_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
vector_assign (scalar_plus_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_vector_range &operator -= (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (*this - ae));
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (*this - ae));
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_vector_range &minus_assign (const vector_expression<AE> &ae) {
vector_assign (scalar_minus_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
vector_assign (scalar_minus_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
return *this;
}
template<class AT>
BOOST_UBLAS_INLINE
matrix_vector_range &operator *= (const AT &at) {
vector_assign_scalar (scalar_multiplies_assign<typename iterator::reference, AT> (), *this, at);
vector_assign_scalar (scalar_multiplies_assign<BOOST_UBLAS_TYPENAME iterator::reference, AT> (), *this, at);
return *this;
}
template<class AT>
BOOST_UBLAS_INLINE
matrix_vector_range &operator /= (const AT &at) {
vector_assign_scalar (scalar_divides_assign<typename iterator::reference, AT> (), *this, at);
vector_assign_scalar (scalar_divides_assign<BOOST_UBLAS_TYPENAME iterator::reference, AT> (), *this, at);
return *this;
}
@@ -1540,7 +1548,11 @@ namespace boost { namespace numeric { namespace ublas {
};
template<class M>
typename matrix_vector_range<M>::matrix_type matrix_vector_range<M>::nil_;
typename matrix_vector_range<M>::matrix_type matrix_vector_range<M>::nil_
#ifdef BOOST_UBLAS_STATIC_OLD_INIT
= BOOST_UBLAS_TYPENAME matrix_vector_range<M>::matrix_type()
#endif
;
// Matrix based vector slice class
template<class M>
@@ -1665,62 +1677,62 @@ namespace boost { namespace numeric { namespace ublas {
matrix_vector_slice &operator = (const matrix_vector_slice &mvs) {
// FIXME: the slices could be differently sized.
// std::copy (mvs.begin (), mvs.end (), begin ());
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (mvs));
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (mvs));
return *this;
}
BOOST_UBLAS_INLINE
matrix_vector_slice &assign_temporary (matrix_vector_slice &mvs) {
// FIXME: this is suboptimal.
// return *this = mvs;
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, mvs);
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, mvs);
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_vector_slice &operator = (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (ae));
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (ae));
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_vector_slice &assign (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_vector_slice &operator += (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (*this + ae));
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (*this + ae));
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_vector_slice &plus_assign (const vector_expression<AE> &ae) {
vector_assign (scalar_plus_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
vector_assign (scalar_plus_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_vector_slice &operator -= (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (*this - ae));
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (*this - ae));
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_vector_slice &minus_assign (const vector_expression<AE> &ae) {
vector_assign (scalar_minus_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
vector_assign (scalar_minus_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
return *this;
}
template<class AT>
BOOST_UBLAS_INLINE
matrix_vector_slice &operator *= (const AT &at) {
vector_assign_scalar (scalar_multiplies_assign<typename iterator::reference, AT> (), *this, at);
vector_assign_scalar (scalar_multiplies_assign<BOOST_UBLAS_TYPENAME iterator::reference, AT> (), *this, at);
return *this;
}
template<class AT>
BOOST_UBLAS_INLINE
matrix_vector_slice &operator /= (const AT &at) {
vector_assign_scalar (scalar_divides_assign<typename iterator::reference, AT> (), *this, at);
vector_assign_scalar (scalar_divides_assign<BOOST_UBLAS_TYPENAME iterator::reference, AT> (), *this, at);
return *this;
}
@@ -2046,7 +2058,11 @@ namespace boost { namespace numeric { namespace ublas {
};
template<class M>
typename matrix_vector_slice<M>::matrix_type matrix_vector_slice<M>::nil_;
typename matrix_vector_slice<M>::matrix_type matrix_vector_slice<M>::nil_
#ifdef BOOST_UBLAS_STATIC_OLD_INIT
= BOOST_UBLAS_TYPENAME matrix_vector_slice<M>::matrix_type()
#endif
;
// Matrix based vector indirection class
template<class M, class IA>
@@ -2172,62 +2188,62 @@ namespace boost { namespace numeric { namespace ublas {
matrix_vector_indirect &operator = (const matrix_vector_indirect &mvi) {
// FIXME: the indirects could be differently sized.
// std::copy (mvi.begin (), mvi.end (), begin ());
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (mvi));
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (mvi));
return *this;
}
BOOST_UBLAS_INLINE
matrix_vector_indirect &assign_temporary (matrix_vector_indirect &mvi) {
// FIXME: this is suboptimal.
// return *this = mvi;
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, mvi);
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, mvi);
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_vector_indirect &operator = (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (ae));
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (ae));
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_vector_indirect &assign (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_vector_indirect &operator += (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (*this + ae));
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (*this + ae));
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_vector_indirect &plus_assign (const vector_expression<AE> &ae) {
vector_assign (scalar_plus_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
vector_assign (scalar_plus_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_vector_indirect &operator -= (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (*this - ae));
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector<value_type> (*this - ae));
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_vector_indirect &minus_assign (const vector_expression<AE> &ae) {
vector_assign (scalar_minus_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
vector_assign (scalar_minus_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
return *this;
}
template<class AT>
BOOST_UBLAS_INLINE
matrix_vector_indirect &operator *= (const AT &at) {
vector_assign_scalar (scalar_multiplies_assign<typename iterator::reference, AT> (), *this, at);
vector_assign_scalar (scalar_multiplies_assign<BOOST_UBLAS_TYPENAME iterator::reference, AT> (), *this, at);
return *this;
}
template<class AT>
BOOST_UBLAS_INLINE
matrix_vector_indirect &operator /= (const AT &at) {
vector_assign_scalar (scalar_divides_assign<typename iterator::reference, AT> (), *this, at);
vector_assign_scalar (scalar_divides_assign<BOOST_UBLAS_TYPENAME iterator::reference, AT> (), *this, at);
return *this;
}
@@ -2553,7 +2569,11 @@ namespace boost { namespace numeric { namespace ublas {
};
template<class M, class IA>
typename matrix_vector_indirect<M, IA>::matrix_type matrix_vector_indirect<M, IA>::nil_;
typename matrix_vector_indirect<M, IA>::matrix_type matrix_vector_indirect<M, IA>::nil_
#ifdef BOOST_UBLAS_STATIC_OLD_INIT
= BOOST_UBLAS_TYPENAME matrix_indirect<M, IA>::matrix_type()
#endif
;
// Matrix based range class
template<class M>
@@ -2673,7 +2693,7 @@ namespace boost { namespace numeric { namespace ublas {
// Assignment
BOOST_UBLAS_INLINE
matrix_range &operator = (const matrix_range &mr) {
matrix_assign (scalar_assign<typename iterator1::reference, value_type> (), *this, mr);
matrix_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator1::reference, value_type> (), *this, mr);
return *this;
}
BOOST_UBLAS_INLINE
@@ -2683,49 +2703,49 @@ namespace boost { namespace numeric { namespace ublas {
template<class AE>
BOOST_UBLAS_INLINE
matrix_range &operator = (const matrix_expression<AE> &ae) {
matrix_assign (scalar_assign<typename iterator1::reference, value_type> (), *this, matrix_type (ae));
matrix_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator1::reference, value_type> (), *this, matrix_type (ae));
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_range &assign (const matrix_expression<AE> &ae) {
matrix_assign (scalar_assign<typename iterator1::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
matrix_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator1::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_range& operator += (const matrix_expression<AE> &ae) {
matrix_assign (scalar_assign<typename iterator1::reference, value_type> (), *this, matrix_type (*this + ae));
matrix_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator1::reference, value_type> (), *this, matrix_type (*this + ae));
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_range &plus_assign (const matrix_expression<AE> &ae) {
matrix_assign (scalar_plus_assign<typename iterator1::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
matrix_assign (scalar_plus_assign<BOOST_UBLAS_TYPENAME iterator1::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_range& operator -= (const matrix_expression<AE> &ae) {
matrix_assign (scalar_assign<typename iterator1::reference, value_type> (), *this, matrix_type (*this - ae));
matrix_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator1::reference, value_type> (), *this, matrix_type (*this - ae));
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_range &minus_assign (const matrix_expression<AE> &ae) {
matrix_assign (scalar_minus_assign<typename iterator1::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
matrix_assign (scalar_minus_assign<BOOST_UBLAS_TYPENAME iterator1::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
return *this;
}
template<class AT>
BOOST_UBLAS_INLINE
matrix_range& operator *= (const AT &at) {
matrix_assign_scalar (scalar_multiplies_assign<typename iterator1::reference, AT> (), *this, at);
matrix_assign_scalar (scalar_multiplies_assign<BOOST_UBLAS_TYPENAME iterator1::reference, AT> (), *this, at);
return *this;
}
template<class AT>
BOOST_UBLAS_INLINE
matrix_range& operator /= (const AT &at) {
matrix_assign_scalar (scalar_divides_assign<typename iterator1::reference, AT> (), *this, at);
matrix_assign_scalar (scalar_divides_assign<BOOST_UBLAS_TYPENAME iterator1::reference, AT> (), *this, at);
return *this;
}
@@ -3448,7 +3468,11 @@ namespace boost { namespace numeric { namespace ublas {
};
template<class M>
typename matrix_range<M>::matrix_type matrix_range<M>::nil_;
typename matrix_range<M>::matrix_type matrix_range<M>::nil_
#ifdef BOOST_UBLAS_STATIC_OLD_INIT
= BOOST_UBLAS_TYPENAME matrix_range<M>::matrix_type()
#endif
;
// Projections
template<class M>
@@ -3609,7 +3633,7 @@ namespace boost { namespace numeric { namespace ublas {
// Assignment
BOOST_UBLAS_INLINE
matrix_slice &operator = (const matrix_slice &ms) {
matrix_assign (scalar_assign<typename iterator1::reference, value_type> (), *this, ms);
matrix_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator1::reference, value_type> (), *this, ms);
return *this;
}
BOOST_UBLAS_INLINE
@@ -3619,49 +3643,49 @@ namespace boost { namespace numeric { namespace ublas {
template<class AE>
BOOST_UBLAS_INLINE
matrix_slice &operator = (const matrix_expression<AE> &ae) {
matrix_assign (scalar_assign<typename iterator1::reference, value_type> (), *this, matrix_type (ae));
matrix_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator1::reference, value_type> (), *this, matrix_type (ae));
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_slice &assign (const matrix_expression<AE> &ae) {
matrix_assign (scalar_assign<typename iterator1::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
matrix_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator1::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_slice& operator += (const matrix_expression<AE> &ae) {
matrix_assign (scalar_assign<typename iterator1::reference, value_type> (), *this, matrix_type (*this + ae));
matrix_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator1::reference, value_type> (), *this, matrix_type (*this + ae));
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_slice &plus_assign (const matrix_expression<AE> &ae) {
matrix_assign (scalar_plus_assign<typename iterator1::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
matrix_assign (scalar_plus_assign<BOOST_UBLAS_TYPENAME iterator1::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_slice& operator -= (const matrix_expression<AE> &ae) {
matrix_assign (scalar_assign<typename iterator1::reference, value_type> (), *this, matrix_type (*this - ae));
matrix_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator1::reference, value_type> (), *this, matrix_type (*this - ae));
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_slice &minus_assign (const matrix_expression<AE> &ae) {
matrix_assign (scalar_minus_assign<typename iterator1::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
matrix_assign (scalar_minus_assign<BOOST_UBLAS_TYPENAME iterator1::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
return *this;
}
template<class AT>
BOOST_UBLAS_INLINE
matrix_slice& operator *= (const AT &at) {
matrix_assign_scalar (scalar_multiplies_assign<typename iterator1::reference, AT> (), *this, at);
matrix_assign_scalar (scalar_multiplies_assign<BOOST_UBLAS_TYPENAME iterator1::reference, AT> (), *this, at);
return *this;
}
template<class AT>
BOOST_UBLAS_INLINE
matrix_slice& operator /= (const AT &at) {
matrix_assign_scalar (scalar_divides_assign<typename iterator1::reference, AT> (), *this, at);
matrix_assign_scalar (scalar_divides_assign<BOOST_UBLAS_TYPENAME iterator1::reference, AT> (), *this, at);
return *this;
}
@@ -4383,7 +4407,11 @@ namespace boost { namespace numeric { namespace ublas {
};
template<class M>
typename matrix_slice<M>::matrix_type matrix_slice<M>::nil_;
typename matrix_slice<M>::matrix_type matrix_slice<M>::nil_
#ifdef BOOST_UBLAS_STATIC_OLD_INIT
= BOOST_UBLAS_TYPENAME matrix_slice<M>::matrix_type()
#endif
;
// Projections
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
@@ -4554,7 +4582,7 @@ namespace boost { namespace numeric { namespace ublas {
// Assignment
BOOST_UBLAS_INLINE
matrix_indirect &operator = (const matrix_indirect &mi) {
matrix_assign (scalar_assign<typename iterator1::reference, value_type> (), *this, mi);
matrix_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator1::reference, value_type> (), *this, mi);
return *this;
}
BOOST_UBLAS_INLINE
@@ -4564,49 +4592,49 @@ namespace boost { namespace numeric { namespace ublas {
template<class AE>
BOOST_UBLAS_INLINE
matrix_indirect &operator = (const matrix_expression<AE> &ae) {
matrix_assign (scalar_assign<typename iterator1::reference, value_type> (), *this, matrix_type (ae));
matrix_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator1::reference, value_type> (), *this, matrix_type (ae));
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_indirect &assign (const matrix_expression<AE> &ae) {
matrix_assign (scalar_assign<typename iterator1::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
matrix_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator1::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_indirect& operator += (const matrix_expression<AE> &ae) {
matrix_assign (scalar_assign<typename iterator1::reference, value_type> (), *this, matrix_type (*this + ae));
matrix_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator1::reference, value_type> (), *this, matrix_type (*this + ae));
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_indirect &plus_assign (const matrix_expression<AE> &ae) {
matrix_assign (scalar_plus_assign<typename iterator1::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
matrix_assign (scalar_plus_assign<BOOST_UBLAS_TYPENAME iterator1::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_indirect& operator -= (const matrix_expression<AE> &ae) {
matrix_assign (scalar_assign<typename iterator1::reference, value_type> (), *this, matrix_type (*this - ae));
matrix_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator1::reference, value_type> (), *this, matrix_type (*this - ae));
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
matrix_indirect &minus_assign (const matrix_expression<AE> &ae) {
matrix_assign (scalar_minus_assign<typename iterator1::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
matrix_assign (scalar_minus_assign<BOOST_UBLAS_TYPENAME iterator1::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
return *this;
}
template<class AT>
BOOST_UBLAS_INLINE
matrix_indirect& operator *= (const AT &at) {
matrix_assign_scalar (scalar_multiplies_assign<typename iterator1::reference, AT> (), *this, at);
matrix_assign_scalar (scalar_multiplies_assign<BOOST_UBLAS_TYPENAME iterator1::reference, AT> (), *this, at);
return *this;
}
template<class AT>
BOOST_UBLAS_INLINE
matrix_indirect& operator /= (const AT &at) {
matrix_assign_scalar (scalar_divides_assign<typename iterator1::reference, AT> (), *this, at);
matrix_assign_scalar (scalar_divides_assign<BOOST_UBLAS_TYPENAME iterator1::reference, AT> (), *this, at);
return *this;
}
@@ -5327,7 +5355,11 @@ namespace boost { namespace numeric { namespace ublas {
};
template<class M, class IA>
typename matrix_indirect<M, IA>::matrix_type matrix_indirect<M, IA>::nil_;
typename matrix_indirect<M, IA>::matrix_type matrix_indirect<M, IA>::nil_
#ifdef BOOST_UBLAS_STATIC_OLD_INIT
= BOOST_UBLAS_TYPENAME matrix_indirect<M, IA>::matrix_type()
#endif
;
// Projections
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING

7
include/boost/numeric/ublas/symmetric.hpp
View File

@@ -2183,7 +2183,12 @@ namespace boost { namespace numeric { namespace ublas {
};
template<class M, class F>
typename symmetric_adaptor<M, F>::matrix_type symmetric_adaptor<M, F>::nil_;
typename symmetric_adaptor<M, F>::matrix_type symmetric_adaptor<M, F>::nil_
#ifdef BOOST_UBLAS_STATIC_OLD_INIT
= BOOST_UBLAS_TYPENAME symmetric_adaptor<M, F>::matrix_type ():
#endif
;
}}}

6
include/boost/numeric/ublas/triangular.hpp
View File

@@ -1849,7 +1849,11 @@ namespace boost { namespace numeric { namespace ublas {
};
template<class M, class F>
typename triangular_adaptor<M, F>::matrix_type triangular_adaptor<M, F>::nil_;
typename triangular_adaptor<M, F>::matrix_type triangular_adaptor<M, F>::nil_
#ifdef BOOST_UBLAS_STATIC_OLD_INIT
= BOOST_UBLAS_TYPENAME triangular_adaptor<M, F>::matrix_type ()
#endif
;
template<class M, class F>
const typename triangular_adaptor<M, F>::value_type triangular_adaptor<M, F>::zero_
#ifdef BOOST_UBLAS_STATIC_OLD_INIT

11
include/boost/numeric/ublas/vector_expression.hpp
View File

@@ -103,7 +103,10 @@ namespace boost { namespace numeric { namespace ublas {
template<class T>
const typename scalar_const_reference<T>::value_type scalar_const_reference<T>::nil_
= BOOST_UBLAS_TYPENAME scalar_const_reference<T>::value_type ();
#ifdef BOOST_UBLAS_STATIC_OLD_INIT
= BOOST_UBLAS_TYPENAME scalar_const_reference<T>::value_type ()
#endif
;
@@ -424,7 +427,11 @@ namespace boost { namespace numeric { namespace ublas {
};
template<class E>
typename vector_reference<E>::expression_type vector_reference<E>::nil_;
typename vector_reference<E>::expression_type vector_reference<E>::nil_
#ifdef BOOST_UBLAS_STATIC_OLD_INIT
= BOOST_UBLAS_TYPENAME vector_reference<E>::expression_type ();
#endif
;
template<class E, class F>
class vector_unary:

82
include/boost/numeric/ublas/vector_proxy.hpp
View File

@@ -139,62 +139,62 @@ namespace boost { namespace numeric { namespace ublas {
vector_range &operator = (const vector_range &vr) {
// FIXME: the ranges could be differently sized.
// std::copy (vr.begin (), vr.end (), begin ());
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector_type (vr));
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector_type (vr));
return *this;
}
BOOST_UBLAS_INLINE
vector_range &assign_temporary (vector_range &vr) {
// FIXME: this is suboptimal.
// return *this = vr;
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vr);
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vr);
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
vector_range &operator = (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector_type (ae));
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector_type (ae));
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
vector_range &assign (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
vector_range &operator += (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector_type (*this + ae));
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector_type (*this + ae));
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
vector_range &plus_assign (const vector_expression<AE> &ae) {
vector_assign (scalar_plus_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
vector_assign (scalar_plus_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
vector_range &operator -= (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector_type (*this - ae));
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector_type (*this - ae));
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
vector_range &minus_assign (const vector_expression<AE> &ae) {
vector_assign (scalar_minus_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
vector_assign (scalar_minus_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
return *this;
}
template<class AT>
BOOST_UBLAS_INLINE
vector_range &operator *= (const AT &at) {
vector_assign_scalar (scalar_multiplies_assign<typename iterator::reference, AT> (), *this, at);
vector_assign_scalar (scalar_multiplies_assign<BOOST_UBLAS_TYPENAME iterator::reference, AT> (), *this, at);
return *this;
}
template<class AT>
BOOST_UBLAS_INLINE
vector_range &operator /= (const AT &at) {
vector_assign_scalar (scalar_divides_assign<typename iterator::reference, AT> (), *this, at);
vector_assign_scalar (scalar_divides_assign<BOOST_UBLAS_TYPENAME iterator::reference, AT> (), *this, at);
return *this;
}
@@ -519,7 +519,11 @@ namespace boost { namespace numeric { namespace ublas {
};
template<class V>
typename vector_range<V>::vector_type vector_range<V>::nil_;
typename vector_range<V>::vector_type vector_range<V>::nil_
#ifdef BOOST_UBLAS_STATIC_OLD_INIT
= BOOST_UBLAS_TYPENAME vector_range<V>::vector_type()
#endif
;
// Projections
template<class V>
@@ -673,69 +677,69 @@ namespace boost { namespace numeric { namespace ublas {
vector_slice &operator = (const vector_slice &vs) {
// FIXME: the slices could be differently sized.
// std::copy (vs.begin (), vs.end (), begin ());
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector_type (vs));
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector_type (vs));
return *this;
}
BOOST_UBLAS_INLINE
vector_slice &assign_temporary (vector_slice &vs) {
// FIXME: this is suboptimal.
// return *this = vs;
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vs);
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vs);
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
vector_slice &operator = (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector_type (ae));
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector_type (ae));
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
vector_slice &assign (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
vector_slice &operator += (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector_type (*this + ae));
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector_type (*this + ae));
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
vector_slice &plus_assign (const vector_expression<AE> &ae) {
vector_assign (scalar_plus_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
vector_assign (scalar_plus_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
vector_slice &operator -= (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector_type (*this - ae));
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector_type (*this - ae));
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
vector_slice &minus_assign (const vector_expression<AE> &ae) {
vector_assign (scalar_minus_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
vector_assign (scalar_minus_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
return *this;
}
template<class AT>
BOOST_UBLAS_INLINE
vector_slice &operator *= (const AT &at) {
vector_assign_scalar (scalar_multiplies_assign<typename iterator::reference, AT> (), *this, at);
vector_assign_scalar (scalar_multiplies_assign<BOOST_UBLAS_TYPENAME iterator::reference, AT> (), *this, at);
return *this;
}
template<class AT>
BOOST_UBLAS_INLINE
vector_slice &operator /= (const AT &at) {
vector_assign_scalar (scalar_divides_assign<typename iterator::reference, AT> (), *this, at);
vector_assign_scalar (scalar_divides_assign<BOOST_UBLAS_TYPENAME iterator::reference, AT> (), *this, at);
return *this;
}
// Closure comparison
BOOST_UBLAS_INLINE
bool same_closure (const vector_slice &vr) const {
return true;
return (*this).data_.same_closure (vr.data_);
}
// Comparison
@@ -1046,8 +1050,12 @@ return true;
};
template<class V>
typename vector_slice<V>::vector_type vector_slice<V>::nil_;
typename vector_slice<V>::vector_type vector_slice<V>::nil_
#ifdef BOOST_UBLAS_STATIC_OLD_INIT
= BOOST_UBLAS_TYPENAME vector_slice<V>::vector_type()
#endif
;
// Projections
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
template<class V>
@@ -1214,62 +1222,62 @@ return true;
vector_indirect &operator = (const vector_indirect &vi) {
// FIXME: the indirect_arrays could be differently sized.
// std::copy (vi.begin (), vi.end (), begin ());
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector_type (vi));
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector_type (vi));
return *this;
}
BOOST_UBLAS_INLINE
vector_indirect &assign_temporary (vector_indirect &vi) {
// FIXME: this is suboptimal.
// return *this = vi;
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vi);
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vi);
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
vector_indirect &operator = (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector_type (ae));
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector_type (ae));
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
vector_indirect &assign (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
vector_indirect &operator += (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector_type (*this + ae));
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector_type (*this + ae));
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
vector_indirect &plus_assign (const vector_expression<AE> &ae) {
vector_assign (scalar_plus_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
vector_assign (scalar_plus_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
vector_indirect &operator -= (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector_type (*this - ae));
vector_assign (scalar_assign<BOOST_UBLAS_TYPENAME iterator::reference, value_type> (), *this, vector_type (*this - ae));
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
vector_indirect &minus_assign (const vector_expression<AE> &ae) {
vector_assign (scalar_minus_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
vector_assign (scalar_minus_assign<BOOST_UBLAS_TYPENAME iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
return *this;
}
template<class AT>
BOOST_UBLAS_INLINE
vector_indirect &operator *= (const AT &at) {
vector_assign_scalar (scalar_multiplies_assign<typename iterator::reference, AT> (), *this, at);
vector_assign_scalar (scalar_multiplies_assign<BOOST_UBLAS_TYPENAME iterator::reference, AT> (), *this, at);
return *this;
}
template<class AT>
BOOST_UBLAS_INLINE
vector_indirect &operator /= (const AT &at) {
vector_assign_scalar (scalar_divides_assign<typename iterator::reference, AT> (), *this, at);
vector_assign_scalar (scalar_divides_assign<BOOST_UBLAS_TYPENAME iterator::reference, AT> (), *this, at);
return *this;
}
@@ -1588,7 +1596,11 @@ return true;
};
template<class V, class IA>
typename vector_indirect<V, IA>::vector_type vector_indirect<V, IA>::nil_;
typename vector_indirect<V, IA>::vector_type vector_indirect<V, IA>::nil_
#ifdef BOOST_UBLAS_STATIC_OLD_INIT
= BOOST_UBLAS_TYPENAME vector_indirect<V, IA>::vector_type()
#endif
;
// Projections
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING