boost/ublas
2
0
Fork 0
mirror of https://github.com/boostorg/ublas.git synced 2026-02-23 04:02:10 +00:00
Code Issues Projects Releases Wiki Activity

New definitions.hpp for noalias and accessors

Browse Source 
New namespace dimensions for accessors

svn path=/trunk/boost/boost/numeric/ublas/; revision=25566
This commit is contained in:
Michael Stevens
2004-10-05 08:12:55 +00:00
parent 90e75885bf
commit 99cf5ca6c4
6 changed files with 195 additions and 115 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
include/boost/numeric/ublas/config.hpp
View File

@@ -357,6 +357,9 @@ bool disable_type_check<Dummy>::value = false;
// #define BOOST_UBLAS_PROXY_CONST_MEMBER
// Include declerations and functions
#include <boost/numeric/ublas/fwd.hpp>
#include <boost/numeric/ublas/definitions.hpp>
#endif

191
include/boost/numeric/ublas/definitions.hpp Normal file
View File

@@ -0,0 +1,191 @@
//
// Copyright (c) 2000-2002
// Joerg Walter, Mathias Koch
//
// Permission to use, copy, modify, distribute and sell this software
// and its documentation for any purpose is hereby granted without fee,
// provided that the above copyright notice appear in all copies and
// that both that copyright notice and this permission notice appear
// in supporting documentation. The authors make no representations
// about the suitability of this software for any purpose.
// It is provided "as is" without express or implied warranty.
//
// The authors gratefully acknowledge the support of
// GeNeSys mbH & Co. KG in producing this work.
//
#ifndef BOOST_UBLAS_DEFINITIONS_H
#define BOOST_UBLAS_DEFINITIONS_H
namespace boost { namespace numeric { namespace ublas {
// Borrowed from Dave Abraham's noncopyable.
// I believe this should be part of utility.hpp one day...
namespace nonassignable_ // protection from unintended ADL
{
class nonassignable {
protected:
nonassignable () {}
~nonassignable () {}
private: // emphasize the following members are private
const nonassignable& operator= (const nonassignable &);
}; // nonassignable
}
typedef nonassignable_::nonassignable nonassignable;
// Assignment proxy.
// Provides temporary free assigment when LHS has no alias on RHS
template<class C>
class noalias_proxy:
private nonassignable {
public:
typedef typename C::closure_type closure_type;
BOOST_UBLAS_INLINE
noalias_proxy (C& lval):
nonassignable (), lval_ (lval) {}
BOOST_UBLAS_INLINE
noalias_proxy (const noalias_proxy& p):
nonassignable (), lval_ (p.lval_) {}
template <class E>
BOOST_UBLAS_INLINE
closure_type &operator= (const E& e) {
lval_.assign (e);
return lval_;
}
template <class E>
BOOST_UBLAS_INLINE
closure_type &operator+= (const E& e) {
lval_.plus_assign (e);
return lval_;
}
template <class E>
BOOST_UBLAS_INLINE
closure_type &operator-= (const E& e) {
lval_.minus_assign (e);
return lval_;
}
private:
closure_type lval_;
};
// Improve syntax of effcient assignment where no aliases of LHS appear on the RHS
// noalias(lhs) = rhs_expression
template <class C>
BOOST_UBLAS_INLINE
noalias_proxy<C> noalias (C& lvalue) {
return noalias_proxy<C> (lvalue);
}
template <class C>
BOOST_UBLAS_INLINE
noalias_proxy<const C> noalias (const C& lvalue) {
return noalias_proxy<const C> (lvalue);
}
// Dimension accessors
namespace dimension {
// Generic accessors
template<unsigned dimension>
struct dimension_properties {};
template<>
struct dimension_properties<1> {
template <class E>
BOOST_UBLAS_INLINE static
typename E::size_type size (const vector_expression<E> &e) {
return e ().size ();
}
template <class E>
BOOST_UBLAS_INLINE static
typename E::size_type size (const matrix_expression<E> &e) {
return e ().size1 ();
}
// Note: Index functions cannot deduce dependant template parameter V or M from i
template <class V>
BOOST_UBLAS_INLINE static
typename V::size_type index (const typename V::iterator &i) {
return i.index ();
}
template <class M>
BOOST_UBLAS_INLINE static
typename M::size_type index (const typename M::iterator1 &i) {
return i.index1 ();
}
template <class M>
BOOST_UBLAS_INLINE static
typename M::size_type index (const typename M::iterator2 &i) {
return i.index1 ();
}
};
template<>
struct dimension_properties<2> {
template <class E>
BOOST_UBLAS_INLINE static
typename E::size_type size (const vector_expression<E> &) {
return 1;
}
template <class E>
BOOST_UBLAS_INLINE static
typename E::size_type size (const matrix_expression<E> &e) {
return e ().size2 ();
}
template <class V>
BOOST_UBLAS_INLINE static
typename V::size_type index (const typename V::iterator &) {
return 1;
}
template <class M>
BOOST_UBLAS_INLINE static
typename M::size_type index (const typename M::iterator1 &i) {
return i.index2 ();
}
template <class M>
BOOST_UBLAS_INLINE static
typename M::size_type index (const typename M::iterator2 &i) {
return i.index2 ();
}
};
template<unsigned dimension, class E>
BOOST_UBLAS_INLINE
typename E::size_type size (const E& e) {
return dimension_properties<dimension>::size (e);
}
template<unsigned dimension, class I>
BOOST_UBLAS_INLINE
typename I::container_type::size_type
index (const I& i) {
typedef typename I::container_type container_type;
return dimension_properties<dimension>::template index<container_type> (i);
}
// Named accessors - just syntactic sugar
template<class V>
typename V::size_type num_elements (const V &v) {
return v.size ();
}
template<class M>
typename M::size_type num_rows (const M &m) {
return m.size1 ();
}
template<class M>
typename M::size_type num_columns (const M &m) {
return m.size2 ();
}
template<class MV>
typename MV::size_type num_non_zeros (const MV &mv) {
return mv.non_zeros ();
}
}
}}}
#endif

2
include/boost/numeric/ublas/functional.hpp
View File

@@ -179,7 +179,7 @@ namespace boost { namespace numeric { namespace ublas {
template<class T1, class T2>
struct scalar_binary_assign_functor {
// Remove reference to avoid reference to reference problems
// ISSUE Remove reference to avoid reference to reference problems
typedef typename type_traits<typename boost::remove_reference<T1>::type>::reference argument1_type;
typedef typename type_traits<T2>::const_reference argument2_type;
};

45
include/boost/numeric/ublas/fwd.hpp
View File

@@ -20,21 +20,6 @@
namespace boost { namespace numeric { namespace ublas {
// Borrowed from Dave Abraham's noncopyable.
// I believe this should be part of utility.hpp one day...
namespace nonassignable_ // protection from unintended ADL
{
class nonassignable {
protected:
nonassignable () {}
~nonassignable () {}
private: // emphasize the following members are private
const nonassignable& operator= (const nonassignable &);
}; // nonassignable
}
typedef nonassignable_::nonassignable nonassignable;
// Storage types
template<class T, class ALLOC = std::allocator<T> >
class unbounded_array;
@@ -101,10 +86,8 @@ namespace boost { namespace numeric { namespace ublas {
template<class T>
class unit_vector;
template<class T>
class zero_vector;
template<class T>
class scalar_vector;
@@ -113,10 +96,8 @@ namespace boost { namespace numeric { namespace ublas {
template<class T, class A = map_std<std::size_t, T> >
class sparse_vector;
template<class T, std::size_t IB = 0, class IA = unbounded_array<std::size_t>, class TA = unbounded_array<T> >
class compressed_vector;
template<class T, std::size_t IB = 0, class IA = unbounded_array<std::size_t>, class TA = unbounded_array<T> >
class coordinate_vector;
@@ -135,10 +116,8 @@ namespace boost { namespace numeric { namespace ublas {
template<class T>
class identity_matrix;
template<class T>
class zero_matrix;
template<class T>
class scalar_matrix;
@@ -167,31 +146,25 @@ namespace boost { namespace numeric { namespace ublas {
template<class T, class F1 = lower, class F2 = row_major, class A = unbounded_array<T> >
class triangular_matrix;
template<class M, class F = lower>
class triangular_adaptor;
template<class T, class F1 = lower, class F2 = row_major, class A = unbounded_array<T> >
class symmetric_matrix;
template<class M, class F = lower>
class symmetric_adaptor;
template<class T, class F1 = lower, class F2 = row_major, class A = unbounded_array<T> >
class hermitian_matrix;
template<class M, class F = lower>
class hermitian_adaptor;
template<class T, class F = row_major, class A = map_std<std::size_t, T> >
class sparse_matrix;
template<class T, class F = row_major, class A = map_std<std::size_t, map_std<std::size_t, T> > >
class sparse_vector_of_sparse_vector;
template<class T, class F = row_major, std::size_t IB = 0, class IA = unbounded_array<std::size_t>, class TA = unbounded_array<T> >
class compressed_matrix;
template<class T, class F = row_major, std::size_t IB = 0, class IA = unbounded_array<std::size_t>, class TA = unbounded_array<T> >
class coordinate_matrix;
@@ -199,24 +172,6 @@ namespace boost { namespace numeric { namespace ublas {
struct concrete_tag {};
struct abstract_tag {};
// Some syntactic sugar. I'd like to drop it ;-)
template<class V>
typename V::size_type num_elements (const V &v) {
return v.size ();
}
template<class M>
typename M::size_type num_rows (const M &m) {
return m.size1 ();
}
template<class M>
typename M::size_type num_columns (const M &m) {
return m.size2 ();
}
template<class MV>
typename MV::size_type num_non_zeros (const MV &mv) {
return mv.non_zeros ();
}
}}}
#endif

68
include/boost/numeric/ublas/noalias.hpp
View File

@@ -1,68 +0,0 @@
//
// Copyright (c) 2004 Michael Stevens
// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef BOOST_UBLAS_NOALIAS_H
#define BOOST_UBLAS_NOALIAS_H
namespace boost { namespace numeric { namespace ublas {
// Assignment proxy.
// Provides temporary free assigment when LHS has no alias on RHS
template<class C>
class noalias_proxy:
private nonassignable {
public:
typedef typename C::closure_type closure_type;
BOOST_UBLAS_INLINE
noalias_proxy (C& lval):
nonassignable (), lval_ (lval) {}
BOOST_UBLAS_INLINE
noalias_proxy (const noalias_proxy& p):
nonassignable (), lval_ (p.lval_) {}
template <class E>
BOOST_UBLAS_INLINE
closure_type &operator= (const E& e) {
lval_.assign (e);
return lval_;
}
template <class E>
BOOST_UBLAS_INLINE
closure_type &operator+= (const E& e) {
lval_.plus_assign (e);
return lval_;
}
template <class E>
BOOST_UBLAS_INLINE
closure_type &operator-= (const E& e) {
lval_.minus_assign (e);
return lval_;
}
private:
closure_type lval_;
};
// Improve syntax of effcient assignment where no aliases of LHS appear on the RHS
// noalias(lhs) = rhs_expression
template <class C>
BOOST_UBLAS_INLINE
noalias_proxy<C> noalias (C& lvalue) {
return noalias_proxy<C> (lvalue);
}
template <class C>
BOOST_UBLAS_INLINE
noalias_proxy<const C> noalias (const C& lvalue) {
return noalias_proxy<const C> (lvalue);
}
}}}
#endif

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

@@ -20,7 +20,6 @@
#include <boost/numeric/ublas/config.hpp>
#include <boost/numeric/ublas/exception.hpp>
#include <boost/numeric/ublas/functional.hpp>
#include <boost/numeric/ublas/noalias.hpp>
// Expression templates based on ideas of Todd Veldhuizen and Geoffrey Furnish
// Iterators based on ideas of Jeremy Siek