boost/ublas
2
0
Fork 0
mirror of https://github.com/boostorg/ublas.git synced 2026-02-27 17:32:09 +00:00
Code Issues Projects Releases Wiki Activity

Fixed runtime exception, must use iterator:reference type

Browse Source 
nil_ back to no static as Default construct requires it. Arrrgg!

svn path=/trunk/boost/boost/numeric/ublas/; revision=24864
This commit is contained in:
Michael Stevens
2004-09-02 11:44:50 +00:00
parent f96ab7be2f
commit f1671656e9
2 changed files with 82 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -133,32 +133,32 @@ 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<reference, value_type> (), *this, vector<value_type> (mr));
vector_assign (scalar_assign<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<reference, value_type> (), *this, mr);
vector_assign (scalar_assign<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<reference, value_type> (), *this, vector<value_type> (ae));
vector_assign (scalar_assign<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<reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
vector_assign (scalar_assign<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<reference, value_type> (), *this, vector<value_type> (*this + ae));
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (*this + ae));
return *this;
}
template<class AE>
@@ -170,7 +170,7 @@ namespace boost { namespace numeric { namespace ublas {
template<class AE>
BOOST_UBLAS_INLINE
matrix_row &operator -= (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<reference, value_type> (), *this, vector<value_type> (*this - ae));
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (*this - ae));
return *this;
}
template<class AE>
@@ -509,11 +509,11 @@ namespace boost { namespace numeric { namespace ublas {
private:
matrix_closure_type data_;
size_type i_;
static const_matrix_type nil_;
static matrix_type nil_;
};
template<class M>
typename matrix_row<M>::const_matrix_type matrix_row<M>::nil_;
typename matrix_row<M>::matrix_type matrix_row<M>::nil_;
// Projections
template<class M>
@@ -642,32 +642,32 @@ 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<reference, value_type> (), *this, vector<value_type> (mc));
vector_assign (scalar_assign<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<reference, value_type> (), *this, mc);
vector_assign (scalar_assign<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<reference, value_type> (), *this, vector<value_type> (ae));
vector_assign (scalar_assign<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<reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
vector_assign (scalar_assign<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<reference, value_type> (), *this, vector<value_type> (*this + ae));
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (*this + ae));
return *this;
}
template<class AE>
@@ -679,7 +679,7 @@ namespace boost { namespace numeric { namespace ublas {
template<class AE>
BOOST_UBLAS_INLINE
matrix_column &operator -= (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<reference, value_type> (), *this, vector<value_type> (*this - ae));
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (*this - ae));
return *this;
}
template<class AE>
@@ -1020,11 +1020,11 @@ namespace boost { namespace numeric { namespace ublas {
private:
matrix_closure_type data_;
size_type j_;
static const_matrix_type nil_;
static matrix_type nil_;
};
template<class M>
typename matrix_column<M>::const_matrix_type matrix_column<M>::nil_;
typename matrix_column<M>::matrix_type matrix_column<M>::nil_;
// Projections
template<class M>
@@ -1161,32 +1161,32 @@ 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<reference, value_type> (), *this, vector<value_type> (mvr));
vector_assign (scalar_assign<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<reference, value_type> (), *this, mvr);
vector_assign (scalar_assign<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<reference, value_type> (), *this, vector<value_type> (ae));
vector_assign (scalar_assign<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<reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
vector_assign (scalar_assign<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<reference, value_type> (), *this, vector<value_type> (*this + ae));
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (*this + ae));
return *this;
}
template<class AE>
@@ -1198,7 +1198,7 @@ namespace boost { namespace numeric { namespace ublas {
template<class AE>
BOOST_UBLAS_INLINE
matrix_vector_range &operator -= (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<reference, value_type> (), *this, vector<value_type> (*this - ae));
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (*this - ae));
return *this;
}
template<class AE>
@@ -1536,11 +1536,11 @@ namespace boost { namespace numeric { namespace ublas {
matrix_closure_type data_;
range r1_;
range r2_;
static const_matrix_type nil_;
static matrix_type nil_;
};
template<class M>
typename matrix_vector_range<M>::const_matrix_type matrix_vector_range<M>::nil_;
typename matrix_vector_range<M>::matrix_type matrix_vector_range<M>::nil_;
// Matrix based vector slice class
template<class M>
@@ -1665,32 +1665,32 @@ 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<reference, value_type> (), *this, vector<value_type> (mvs));
vector_assign (scalar_assign<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<reference, value_type> (), *this, mvs);
vector_assign (scalar_assign<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<reference, value_type> (), *this, vector<value_type> (ae));
vector_assign (scalar_assign<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<reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
vector_assign (scalar_assign<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<reference, value_type> (), *this, vector<value_type> (*this + ae));
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (*this + ae));
return *this;
}
template<class AE>
@@ -1702,7 +1702,7 @@ namespace boost { namespace numeric { namespace ublas {
template<class AE>
BOOST_UBLAS_INLINE
matrix_vector_slice &operator -= (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<reference, value_type> (), *this, vector<value_type> (*this - ae));
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (*this - ae));
return *this;
}
template<class AE>
@@ -2042,11 +2042,11 @@ namespace boost { namespace numeric { namespace ublas {
matrix_closure_type data_;
slice s1_;
slice s2_;
static const_matrix_type nil_;
static matrix_type nil_;
};
template<class M>
typename matrix_vector_slice<M>::const_matrix_type matrix_vector_slice<M>::nil_;
typename matrix_vector_slice<M>::matrix_type matrix_vector_slice<M>::nil_;
// Matrix based vector indirection class
template<class M, class IA>
@@ -2172,32 +2172,32 @@ 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<reference, value_type> (), *this, vector<value_type> (mvi));
vector_assign (scalar_assign<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<reference, value_type> (), *this, mvi);
vector_assign (scalar_assign<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<reference, value_type> (), *this, vector<value_type> (ae));
vector_assign (scalar_assign<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<reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
vector_assign (scalar_assign<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<reference, value_type> (), *this, vector<value_type> (*this + ae));
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (*this + ae));
return *this;
}
template<class AE>
@@ -2209,7 +2209,7 @@ namespace boost { namespace numeric { namespace ublas {
template<class AE>
BOOST_UBLAS_INLINE
matrix_vector_indirect &operator -= (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<reference, value_type> (), *this, vector<value_type> (*this - ae));
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector<value_type> (*this - ae));
return *this;
}
template<class AE>
@@ -2549,11 +2549,11 @@ namespace boost { namespace numeric { namespace ublas {
matrix_closure_type data_;
indirect_array_type ia1_;
indirect_array_type ia2_;
static const_matrix_type nil_;
static matrix_type nil_;
};
template<class M, class IA>
typename matrix_vector_indirect<M, IA>::const_matrix_type matrix_vector_indirect<M, IA>::nil_;
typename matrix_vector_indirect<M, IA>::matrix_type matrix_vector_indirect<M, IA>::nil_;
// Matrix based range class
template<class M>
@@ -2673,7 +2673,7 @@ namespace boost { namespace numeric { namespace ublas {
// Assignment
BOOST_UBLAS_INLINE
matrix_range &operator = (const matrix_range &mr) {
matrix_assign (scalar_assign<reference, value_type> (), *this, mr);
matrix_assign (scalar_assign<typename iterator1::reference, value_type> (), *this, mr);
return *this;
}
BOOST_UBLAS_INLINE
@@ -2683,19 +2683,19 @@ namespace boost { namespace numeric { namespace ublas {
template<class AE>
BOOST_UBLAS_INLINE
matrix_range &operator = (const matrix_expression<AE> &ae) {
matrix_assign (scalar_assign<reference, value_type> (), *this, matrix<value_type> (ae));
matrix_assign (scalar_assign<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<reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
matrix_assign (scalar_assign<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<reference, value_type> (), *this, matrix<value_type> (*this + ae));
matrix_assign (scalar_assign<typename iterator1::reference, value_type> (), *this, matrix_type (*this + ae));
return *this;
}
template<class AE>
@@ -2707,7 +2707,7 @@ namespace boost { namespace numeric { namespace ublas {
template<class AE>
BOOST_UBLAS_INLINE
matrix_range& operator -= (const matrix_expression<AE> &ae) {
matrix_assign (scalar_assign<reference, value_type> (), *this, matrix<value_type> (*this - ae));
matrix_assign (scalar_assign<typename iterator1::reference, value_type> (), *this, matrix_type (*this - ae));
return *this;
}
template<class AE>
@@ -3444,11 +3444,11 @@ namespace boost { namespace numeric { namespace ublas {
matrix_closure_type data_;
range r1_;
range r2_;
static const_matrix_type nil_;
static matrix_type nil_;
};
template<class M>
typename matrix_range<M>::const_matrix_type matrix_range<M>::nil_;
typename matrix_range<M>::matrix_type matrix_range<M>::nil_;
// Projections
template<class M>
@@ -3609,7 +3609,7 @@ namespace boost { namespace numeric { namespace ublas {
// Assignment
BOOST_UBLAS_INLINE
matrix_slice &operator = (const matrix_slice &ms) {
matrix_assign (scalar_assign<reference, value_type> (), *this, ms);
matrix_assign (scalar_assign<typename iterator1::reference, value_type> (), *this, ms);
return *this;
}
BOOST_UBLAS_INLINE
@@ -3619,19 +3619,19 @@ namespace boost { namespace numeric { namespace ublas {
template<class AE>
BOOST_UBLAS_INLINE
matrix_slice &operator = (const matrix_expression<AE> &ae) {
matrix_assign (scalar_assign<reference, value_type> (), *this, matrix<value_type> (ae));
matrix_assign (scalar_assign<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<reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
matrix_assign (scalar_assign<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<reference, value_type> (), *this, matrix<value_type> (*this + ae));
matrix_assign (scalar_assign<typename iterator1::reference, value_type> (), *this, matrix_type (*this + ae));
return *this;
}
template<class AE>
@@ -3643,7 +3643,7 @@ namespace boost { namespace numeric { namespace ublas {
template<class AE>
BOOST_UBLAS_INLINE
matrix_slice& operator -= (const matrix_expression<AE> &ae) {
matrix_assign (scalar_assign<reference, value_type> (), *this, matrix<value_type> (*this - ae));
matrix_assign (scalar_assign<typename iterator1::reference, value_type> (), *this, matrix_type (*this - ae));
return *this;
}
template<class AE>
@@ -4379,11 +4379,11 @@ namespace boost { namespace numeric { namespace ublas {
matrix_closure_type data_;
slice s1_;
slice s2_;
static const_matrix_type nil_;
static matrix_type nil_;
};
template<class M>
typename matrix_slice<M>::const_matrix_type matrix_slice<M>::nil_;
typename matrix_slice<M>::matrix_type matrix_slice<M>::nil_;
// Projections
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
@@ -4554,7 +4554,7 @@ namespace boost { namespace numeric { namespace ublas {
// Assignment
BOOST_UBLAS_INLINE
matrix_indirect &operator = (const matrix_indirect &mi) {
matrix_assign (scalar_assign<reference, value_type> (), *this, mi);
matrix_assign (scalar_assign<typename iterator1::reference, value_type> (), *this, mi);
return *this;
}
BOOST_UBLAS_INLINE
@@ -4564,19 +4564,19 @@ namespace boost { namespace numeric { namespace ublas {
template<class AE>
BOOST_UBLAS_INLINE
matrix_indirect &operator = (const matrix_expression<AE> &ae) {
matrix_assign (scalar_assign<reference, value_type> (), *this, matrix<value_type> (ae));
matrix_assign (scalar_assign<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<reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
matrix_assign (scalar_assign<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<reference, value_type> (), *this, matrix<value_type> (*this + ae));
matrix_assign (scalar_assign<typename iterator1::reference, value_type> (), *this, matrix_type (*this + ae));
return *this;
}
template<class AE>
@@ -4588,7 +4588,7 @@ namespace boost { namespace numeric { namespace ublas {
template<class AE>
BOOST_UBLAS_INLINE
matrix_indirect& operator -= (const matrix_expression<AE> &ae) {
matrix_assign (scalar_assign<reference, value_type> (), *this, matrix<value_type> (*this - ae));
matrix_assign (scalar_assign<typename iterator1::reference, value_type> (), *this, matrix_type (*this - ae));
return *this;
}
template<class AE>
@@ -5323,11 +5323,11 @@ namespace boost { namespace numeric { namespace ublas {
matrix_closure_type data_;
indirect_array_type ia1_;
indirect_array_type ia2_;
static const_matrix_type nil_;
static matrix_type nil_;
};
template<class M, class IA>
typename matrix_indirect<M, IA>::const_matrix_type matrix_indirect<M, IA>::nil_;
typename matrix_indirect<M, IA>::matrix_type matrix_indirect<M, IA>::nil_;
// Projections
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING

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

@@ -139,7 +139,7 @@ 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<reference, value_type> (), *this, vector<value_type> (vr));
vector_assign (scalar_assign<typename iterator::reference, value_type> (), *this, vector_type (vr));
return *this;
}
BOOST_UBLAS_INLINE
@@ -152,37 +152,37 @@ namespace boost { namespace numeric { namespace ublas {
template<class AE>
BOOST_UBLAS_INLINE
vector_range &operator = (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<reference, value_type> (), *this, vector<value_type> (ae));
vector_assign (scalar_assign<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<reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
vector_assign (scalar_assign<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<reference, value_type> (), *this, vector<value_type> (*this + ae));
vector_assign (scalar_assign<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<reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
vector_assign (scalar_plus_assign<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<reference, value_type> (), *this, vector<value_type> (*this - ae));
vector_assign (scalar_assign<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<reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
vector_assign (scalar_minus_assign<typename iterator::reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
return *this;
}
template<class AT>
@@ -515,11 +515,11 @@ namespace boost { namespace numeric { namespace ublas {
private:
vector_closure_type data_;
range r_;
static const_vector_type nil_;
static vector_type nil_;
};
template<class V>
typename vector_range<V>::const_vector_type vector_range<V>::nil_;
typename vector_range<V>::vector_type vector_range<V>::nil_;
// Projections
template<class V>
@@ -673,7 +673,7 @@ 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<reference, value_type> (), *this, vector<value_type> (vs));
vector_assign (scalar_assign<reference, value_type> (), *this, vector_type (vs));
return *this;
}
BOOST_UBLAS_INLINE
@@ -686,7 +686,7 @@ namespace boost { namespace numeric { namespace ublas {
template<class AE>
BOOST_UBLAS_INLINE
vector_slice &operator = (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<reference, value_type> (), *this, vector<value_type> (ae));
vector_assign (scalar_assign<reference, value_type> (), *this, vector_type (ae));
return *this;
}
template<class AE>
@@ -698,7 +698,7 @@ namespace boost { namespace numeric { namespace ublas {
template<class AE>
BOOST_UBLAS_INLINE
vector_slice &operator += (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<reference, value_type> (), *this, vector<value_type> (*this + ae));
vector_assign (scalar_assign<reference, value_type> (), *this, vector_type (*this + ae));
return *this;
}
template<class AE>
@@ -710,7 +710,7 @@ namespace boost { namespace numeric { namespace ublas {
template<class AE>
BOOST_UBLAS_INLINE
vector_slice &operator -= (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<reference, value_type> (), *this, vector<value_type> (*this - ae));
vector_assign (scalar_assign<reference, value_type> (), *this, vector_type (*this - ae));
return *this;
}
template<class AE>
@@ -1042,11 +1042,11 @@ return true;
#endif
vector_closure_type data_;
slice s_;
static const_vector_type nil_;
static vector_type nil_;
};
template<class V>
typename vector_slice<V>::const_vector_type vector_slice<V>::nil_;
typename vector_slice<V>::vector_type vector_slice<V>::nil_;
// Projections
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
@@ -1214,7 +1214,7 @@ 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<reference, value_type> (), *this, vector<value_type> (vi));
vector_assign (scalar_assign<reference, value_type> (), *this, vector_type (vi));
return *this;
}
BOOST_UBLAS_INLINE
@@ -1227,7 +1227,7 @@ return true;
template<class AE>
BOOST_UBLAS_INLINE
vector_indirect &operator = (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<reference, value_type> (), *this, vector<value_type> (ae));
vector_assign (scalar_assign<reference, value_type> (), *this, vector_type (ae));
return *this;
}
template<class AE>
@@ -1239,7 +1239,7 @@ return true;
template<class AE>
BOOST_UBLAS_INLINE
vector_indirect &operator += (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<reference, value_type> (), *this, vector<value_type> (*this + ae));
vector_assign (scalar_assign<reference, value_type> (), *this, vector_type (*this + ae));
return *this;
}
template<class AE>
@@ -1251,7 +1251,7 @@ return true;
template<class AE>
BOOST_UBLAS_INLINE
vector_indirect &operator -= (const vector_expression<AE> &ae) {
vector_assign (scalar_assign<reference, value_type> (), *this, vector<value_type> (*this - ae));
vector_assign (scalar_assign<reference, value_type> (), *this, vector_type (*this - ae));
return *this;
}
template<class AE>
@@ -1584,11 +1584,11 @@ return true;
#endif
vector_closure_type data_;
indirect_array_type ia_;
static const_vector_type nil_;
static vector_type nil_;
};
template<class V, class IA>
typename vector_indirect<V, IA>::const_vector_type vector_indirect<V, IA>::nil_;
typename vector_indirect<V, IA>::vector_type vector_indirect<V, IA>::nil_;
// Projections
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING