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

Deprecated SCALAR_ET removed

Browse Source 
Simplief to use references directly. conversion from scalar_reference causes massive problems with intervals


[SVN r27670]
This commit is contained in:
Michael Stevens
2005-03-15 14:19:04 +00:00
parent 17c06c3460
commit c7f693b7bf
2 changed files with 49 additions and 128 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -2571,16 +2571,16 @@ namespace boost { namespace numeric { namespace ublas {
return expression_type (e1 (), e2 ());
}
template<class E1, class E2, class F, class C1>
template<class E1, class E2, class F>
class matrix_binary_scalar1:
public matrix_expression<matrix_binary_scalar1<E1, E2, F, C1> > {
public matrix_expression<matrix_binary_scalar1<E1, E2, F> > {
typedef E1 expression1_type;
typedef E2 expression2_type;
typedef F functor_type;
typedef C1 expression1_closure_type;
typedef const E1& expression1_closure_type;
typedef typename E2::const_closure_type expression2_closure_type;
typedef matrix_binary_scalar1<E1, E2, F, C1> self_type;
typedef matrix_binary_scalar1<E1, E2, F> self_type;
public:
#ifndef BOOST_UBLAS_NO_PROXY_SHORTCUTS
using matrix_expression<self_type>::operator ();
@@ -2613,10 +2613,6 @@ namespace boost { namespace numeric { namespace ublas {
return e2_.size2 ();
}
public:
expression1_closure_type const& expression1() const { return e1_ ; }
expression2_closure_type const& expression2() const { return e2_ ; }
public:
// Element access
BOOST_UBLAS_INLINE
@@ -2627,7 +2623,7 @@ namespace boost { namespace numeric { namespace ublas {
// Closure comparison
BOOST_UBLAS_INLINE
bool same_closure (const matrix_binary_scalar1 &mbs1) const {
return (*this).e1_.same_closure (mbs1.e1_) &&
return &e1_ == &(mbs1.e1_) &&
(*this).e2_.same_closure (mbs1.e2_);
}
@@ -2979,9 +2975,9 @@ namespace boost { namespace numeric { namespace ublas {
expression2_closure_type e2_;
};
template<class E1, class E2, class F, class C1 = typename E1::const_closure_type>
template<class E1, class E2, class F>
struct matrix_binary_scalar1_traits {
typedef matrix_binary_scalar1<E1, E2, F, C1> expression_type; // allow E1 to be builtin type
typedef matrix_binary_scalar1<E1, E2, F> expression_type; // allow E1 to be builtin type
#ifndef BOOST_UBLAS_SIMPLE_ET_DEBUG
typedef expression_type result_type;
#else
@@ -2989,41 +2985,29 @@ namespace boost { namespace numeric { namespace ublas {
#endif
};
#ifdef BOOST_UBLAS_USE_SCALAR_ET
// (s * m) [i] = scalar_expression * m [i]
template<class E1, class E2>
BOOST_UBLAS_INLINE
typename matrix_binary_scalar1_traits<E1, E2, scalar_multiplies<typename E1::value_type, typename E2::value_type> >::result_type
operator * (const scalar_expression<E1> &e1,
const matrix_expression<E2> &e2) {
typedef typename matrix_binary_scalar1_traits<E1, E2, scalar_multiplies<typename E1::value_type, typename E2::value_type> >::expression_type expression_type;
return expression_type (e1 (), e2 ());
}
#endif
// (t * m) [i] [j] = t * m [i] [j]
template<class T1, class E2>
BOOST_UBLAS_INLINE
typename matrix_binary_scalar1_traits<const T1, E2, scalar_multiplies<T1, typename E2::value_type>, scalar_reference<const T1> >::result_type
typename matrix_binary_scalar1_traits<const T1, E2, scalar_multiplies<T1, typename E2::value_type> >::result_type
operator * (const T1 &e1,
const matrix_expression<E2> &e2) {
typedef typename matrix_binary_scalar1_traits<const T1, E2, scalar_multiplies<T1, typename E2::value_type>, scalar_reference<const T1> >::expression_type expression_type;
typedef typename matrix_binary_scalar1_traits<const T1, E2, scalar_multiplies<T1, typename E2::value_type> >::expression_type expression_type;
return expression_type (e1, e2 ());
}
template<class E1, class E2, class F, class C2>
template<class E1, class E2, class F>
class matrix_binary_scalar2:
public matrix_expression<matrix_binary_scalar2<E1, E2, F, C2> > {
public matrix_expression<matrix_binary_scalar2<E1, E2, F> > {
typedef E1 expression1_type;
typedef E2 expression2_type;
typedef F functor_type;
public:
typedef typename E1::const_closure_type expression1_closure_type;
typedef C2 expression2_closure_type;
typedef const E2& expression2_closure_type;
private:
typedef matrix_binary_scalar2<E1, E2, F, C2> self_type;
typedef matrix_binary_scalar2<E1, E2, F> self_type;
public:
#ifndef BOOST_UBLAS_NO_PROXY_SHORTCUTS
using matrix_expression<self_type>::operator ();
@@ -3057,10 +3041,6 @@ namespace boost { namespace numeric { namespace ublas {
return e1_.size2 ();
}
public:
expression1_closure_type const& expression1() const { return e1_ ; }
expression2_closure_type const& expression2() const { return e2_ ; }
public:
// Element access
BOOST_UBLAS_INLINE
@@ -3072,7 +3052,7 @@ namespace boost { namespace numeric { namespace ublas {
BOOST_UBLAS_INLINE
bool same_closure (const matrix_binary_scalar2 &mbs2) const {
return (*this).e1_.same_closure (mbs2.e1_) &&
(*this).e2_.same_closure (mbs2.e2_);
&e2_ == &(mbs2.e2_);
}
// Iterator types
@@ -3423,9 +3403,9 @@ namespace boost { namespace numeric { namespace ublas {
expression2_closure_type e2_;
};
template<class E1, class E2, class F, class C2 = typename E2::const_closure_type>
template<class E1, class E2, class F>
struct matrix_binary_scalar2_traits {
typedef matrix_binary_scalar2<E1, E2, F, C2> expression_type; // allow E2 to be builtin type
typedef matrix_binary_scalar2<E1, E2, F> expression_type; // allow E2 to be builtin type
#ifndef BOOST_UBLAS_SIMPLE_ET_DEBUG
typedef expression_type result_type;
#else
@@ -3433,45 +3413,23 @@ namespace boost { namespace numeric { namespace ublas {
#endif
};
#ifdef BOOST_UBLAS_USE_SCALAR_ET
// (m * s) [i] = m [i] * scalar_expression
template<class E1, class E2>
BOOST_UBLAS_INLINE
typename matrix_binary_scalar2_traits<E1, E2, scalar_multiplies<typename E1::value_type, typename E2::value_type> >::result_type
operator * (const matrix_expression<E1> &e1,
const scalar_expression<E2> &e2) {
typedef typename matrix_binary_scalar2_traits<E1, E2, scalar_multiplies<typename E1::value_type, typename E2::value_type> >::expression_type expression_type;
return expression_type (e1 (), e2 ());
}
// (m / s) [i] = m [i] / scalar_expression
template<class E1, class E2>
BOOST_UBLAS_INLINE
typename matrix_binary_scalar2_traits<E1, E2, scalar_divides<typename E1::value_type, typename E2::value_type> >::result_type
operator / (const matrix_expression<E1> &e1,
const scalar_expression<E2> &e2) {
typedef typename matrix_binary_scalar2_traits<E1, E2, scalar_divides<typename E1::value_type, typename E2::value_type> >::expression_type expression_type;
return expression_type (e1 (), e2 ());
}
#endif
// (m * t) [i] [j] = m [i] [j] * t
template<class E1, class T2>
BOOST_UBLAS_INLINE
typename matrix_binary_scalar2_traits<E1, const T2, scalar_multiplies<typename E1::value_type, T2>, scalar_reference<const T2> >::result_type
typename matrix_binary_scalar2_traits<E1, const T2, scalar_multiplies<typename E1::value_type, T2> >::result_type
operator * (const matrix_expression<E1> &e1,
const T2 &e2) {
typedef typename matrix_binary_scalar2_traits<E1, const T2, scalar_multiplies<typename E1::value_type, T2>, scalar_reference<const T2> >::expression_type expression_type;
typedef typename matrix_binary_scalar2_traits<E1, const T2, scalar_multiplies<typename E1::value_type, T2> >::expression_type expression_type;
return expression_type (e1 (), e2);
}
// (m / t) [i] [j] = m [i] [j] / t
template<class E1, class T2>
BOOST_UBLAS_INLINE
typename matrix_binary_scalar2_traits<E1, const T2, scalar_divides<typename E1::value_type, T2>, scalar_reference<const T2> >::result_type
typename matrix_binary_scalar2_traits<E1, const T2, scalar_divides<typename E1::value_type, T2> >::result_type
operator / (const matrix_expression<E1> &e1,
const T2 &e2) {
typedef typename matrix_binary_scalar2_traits<E1, const T2, scalar_divides<typename E1::value_type, T2>, scalar_reference<const T2> >::expression_type expression_type;
typedef typename matrix_binary_scalar2_traits<E1, const T2, scalar_divides<typename E1::value_type, T2> >::expression_type expression_type;
return expression_type (e1 (), e2);
}

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

@@ -91,6 +91,7 @@ namespace boost { namespace numeric { namespace ublas {
explicit scalar_reference (reference t):
t_ (t) {}
// Conversion
BOOST_UBLAS_INLINE
operator value_type () const {
return t_;
@@ -802,8 +803,8 @@ namespace boost { namespace numeric { namespace ublas {
return BOOST_UBLAS_SAME (e1_.size (), e2_.size ());
}
public:
// Expression accesors
private:
// Accessors
BOOST_UBLAS_INLINE
const expression1_closure_type &expression1 () const {
return e1_;
@@ -1147,21 +1148,21 @@ namespace boost { namespace numeric { namespace ublas {
}
template<class E1, class E2, class F, class C1>
template<class E1, class E2, class F>
class vector_binary_scalar1:
public vector_expression<vector_binary_scalar1<E1, E2, F, C1> > {
public vector_expression<vector_binary_scalar1<E1, E2, F> > {
typedef F functor_type;
typedef E1 expression1_type;
typedef E2 expression2_type;
public:
typedef C1 expression1_closure_type;
typedef const E1& expression1_closure_type;
typedef typename E2::const_closure_type expression2_closure_type;
private:
typedef vector_binary_scalar1<E1, E2, F, C1> self_type;
typedef vector_binary_scalar1<E1, E2, F> self_type;
public:
#ifndef BOOST_UBLAS_NO_PROXY_SHORTCUTS
using vector_expression<vector_binary_scalar1<E1, E2, F, C1> >::operator ();
using vector_expression<vector_binary_scalar1<E1, E2, F> >::operator ();
#endif
typedef typename E2::size_type size_type;
typedef typename E2::difference_type difference_type;
@@ -1186,26 +1187,22 @@ namespace boost { namespace numeric { namespace ublas {
return e2_.size ();
}
public:
expression1_closure_type const& expression1() const { return e1_ ; }
expression2_closure_type const& expression2() const { return e2_ ; }
public:
// Element access
BOOST_UBLAS_INLINE
const_reference operator () (size_type i) const {
return functor_type::apply (expression1_type (e1_), e2_ (i));
return functor_type::apply (e1_, e2_ (i));
}
BOOST_UBLAS_INLINE
const_reference operator [] (size_type i) const {
return functor_type::apply (expression1_type (e1_), e2_ [i]);
return functor_type::apply (e1_, e2_ [i]);
}
// Closure comparison
BOOST_UBLAS_INLINE
bool same_closure (const vector_binary_scalar1 &vbs1) const {
return (*this).e1_.same_closure (vbs1.e1_) &&
return &e1_ == &(vbs1.e1_) &&
(*this).e2_.same_closure (vbs1.e2_);
}
@@ -1356,9 +1353,9 @@ namespace boost { namespace numeric { namespace ublas {
expression2_closure_type e2_;
};
template<class E1, class E2, class F, class C1 = typename E1::const_closure_type>
template<class E1, class E2, class F>
struct vector_binary_scalar1_traits {
typedef vector_binary_scalar1<E1, E2, F, C1> expression_type; // allow E1 to be builtin type
typedef vector_binary_scalar1<E1, E2, F> expression_type; // allow E1 to be builtin type
#ifndef BOOST_UBLAS_SIMPLE_ET_DEBUG
typedef expression_type result_type;
#else
@@ -1366,42 +1363,30 @@ namespace boost { namespace numeric { namespace ublas {
#endif
};
#ifdef BOOST_UBLAS_USE_SCALAR_ET
// (s * v) [i] = scalar_expression * v [i]
template<class E1, class E2>
BOOST_UBLAS_INLINE
typename vector_binary_scalar1_traits<E1, E2, scalar_multiplies<typename E1::value_type, typename E2::value_type> >::result_type
operator * (const scalar_expression<E1> &e1,
const vector_expression<E2> &e2) {
typedef typename vector_binary_scalar1_traits<E1, E2, scalar_multiplies<typename E1::value_type, typename E2::value_type> >::expression_type expression_type;
return expression_type (e1 (), e2 ());
}
#endif
// (t * v) [i] = t * v [i]
template<class T1, class E2>
BOOST_UBLAS_INLINE
typename vector_binary_scalar1_traits<const T1, E2, scalar_multiplies<T1, typename E2::value_type>, scalar_reference<const T1> >::result_type
typename vector_binary_scalar1_traits<const T1, E2, scalar_multiplies<T1, typename E2::value_type> >::result_type
operator * (const T1 &e1,
const vector_expression<E2> &e2) {
typedef typename vector_binary_scalar1_traits<const T1, E2, scalar_multiplies<T1, typename E2::value_type>, scalar_reference<const T1> >::expression_type expression_type;
typedef typename vector_binary_scalar1_traits<const T1, E2, scalar_multiplies<T1, typename E2::value_type> >::expression_type expression_type;
return expression_type (e1, e2 ());
}
template<class E1, class E2, class F, class C2>
template<class E1, class E2, class F>
class vector_binary_scalar2:
public vector_expression<vector_binary_scalar2<E1, E2, F, C2> > {
public vector_expression<vector_binary_scalar2<E1, E2, F> > {
typedef F functor_type;
typedef E1 expression1_type;
typedef E2 expression2_type;
typedef typename E1::const_closure_type expression1_closure_type;
typedef C2 expression2_closure_type;
typedef vector_binary_scalar2<E1, E2, F, C2> self_type;
typedef const E2& expression2_closure_type;
typedef vector_binary_scalar2<E1, E2, F> self_type;
public:
#ifndef BOOST_UBLAS_NO_PROXY_SHORTCUTS
using vector_expression<vector_binary_scalar2<E1, E2, F, C2> >::operator ();
using vector_expression<vector_binary_scalar2<E1, E2, F> >::operator ();
#endif
typedef typename E1::size_type size_type;
typedef typename E1::difference_type difference_type;
@@ -1430,19 +1415,19 @@ namespace boost { namespace numeric { namespace ublas {
// Element access
BOOST_UBLAS_INLINE
const_reference operator () (size_type i) const {
return functor_type::apply (e1_ (i), expression2_type (e2_));
return functor_type::apply (e1_ (i), e2_);
}
BOOST_UBLAS_INLINE
const_reference operator [] (size_type i) const {
return functor_type::apply (e1_ [i], expression2_type (e2_));
return functor_type::apply (e1_ [i], e2_);
}
// Closure comparison
BOOST_UBLAS_INLINE
bool same_closure (const vector_binary_scalar2 &vbs2) const {
return (*this).e1_.same_closure (vbs2.e1_) &&
(*this).e2_.same_closure (vbs2.e2_);
&e2_ == &(vbs2.e2_);
}
// Iterator types
@@ -1592,9 +1577,9 @@ namespace boost { namespace numeric { namespace ublas {
expression2_closure_type e2_;
};
template<class E1, class E2, class F, class C2 = typename E2::const_closure_type>
template<class E1, class E2, class F>
struct vector_binary_scalar2_traits {
typedef vector_binary_scalar2<E1, E2, F, C2> expression_type; // allow E2 to be builtin type
typedef vector_binary_scalar2<E1, E2, F> expression_type; // allow E2 to be builtin type
#ifndef BOOST_UBLAS_SIMPLE_ET_DEBUG
typedef expression_type result_type;
#else
@@ -1602,45 +1587,23 @@ namespace boost { namespace numeric { namespace ublas {
#endif
};
#ifdef BOOST_UBLAS_USE_SCALAR_ET
// (v * s) [i] = v [i] * scalar_expression
template<class E1, class E2>
BOOST_UBLAS_INLINE
typename vector_binary_scalar2_traits<E1, E2, scalar_multiplies<typename E1::value_type, typename E2::value_type> >::result_type
operator * (const vector_expression<E1> &e1,
const scalar_expression<E2> &e2) {
typedef typename vector_binary_scalar2_traits<E1, E2, scalar_multiplies<typename E1::value_type, typename E2::value_type> >::expression_type expression_type;
return expression_type (e1 (), e2 ());
}
// (v / s) [i] = v [i] / scalar_expression
template<class E1, class E2>
BOOST_UBLAS_INLINE
typename vector_binary_scalar2_traits<E1, E2, scalar_divides<typename E1::value_type, typename E2::value_type> >::result_type
operator / (const vector_expression<E1> &e1,
const scalar_expression<E2> &e2) {
typedef typename vector_binary_scalar2_traits<E1, E2, scalar_divides<typename E1::value_type, typename E2::value_type> >::expression_type expression_type;
return expression_type (e1 (), e2 ());
}
#endif
// (v * t) [i] = v [i] * t
template<class E1, class T2>
BOOST_UBLAS_INLINE
typename vector_binary_scalar2_traits<E1, const T2, scalar_multiplies<typename E1::value_type, T2>, scalar_reference<const T2> >::result_type
typename vector_binary_scalar2_traits<E1, const T2, scalar_multiplies<typename E1::value_type, T2> >::result_type
operator * (const vector_expression<E1> &e1,
const T2 &e2) {
typedef typename vector_binary_scalar2_traits<E1, const T2, scalar_multiplies<typename E1::value_type, T2>, scalar_reference<const T2> >::expression_type expression_type;
typedef typename vector_binary_scalar2_traits<E1, const T2, scalar_multiplies<typename E1::value_type, T2> >::expression_type expression_type;
return expression_type (e1 (), e2);
}
// (v / t) [i] = v [i] / t
template<class E1, class T2>
BOOST_UBLAS_INLINE
typename vector_binary_scalar2_traits<E1, const T2, scalar_divides<typename E1::value_type, T2>, scalar_reference<const T2> >::result_type
typename vector_binary_scalar2_traits<E1, const T2, scalar_divides<typename E1::value_type, T2> >::result_type
operator / (const vector_expression<E1> &e1,
const T2 &e2) {
typedef typename vector_binary_scalar2_traits<E1, const T2, scalar_divides<typename E1::value_type, T2>, scalar_reference<const T2> >::expression_type expression_type;
typedef typename vector_binary_scalar2_traits<E1, const T2, scalar_divides<typename E1::value_type, T2> >::expression_type expression_type;
return expression_type (e1 (), e2);
}