📄 matrix.hpp
字号:
// This could be better for performance,
// typedef typename unknown_orientation_tag orientation_category;
// but others depend on the orientation information...
typedef typename functor_type::orientation_category orientation_category;
// Construction and destruction
BOOST_UBLAS_INLINE
vector_of_vector ():
matrix_expression<self_type> (),
size1_ (0), size2_ (0), data_ (1) {}
BOOST_UBLAS_INLINE
vector_of_vector (size_type size1, size_type size2):
matrix_expression<self_type> (),
size1_ (size1), size2_ (size2), data_ (1) {
resize (size1, size2);
}
BOOST_UBLAS_INLINE
vector_of_vector (const vector_of_vector &m):
matrix_expression<self_type> (),
size1_ (m.size1_), size2_ (m.size2_), data_ (m.data_) {}
template<class AE>
BOOST_UBLAS_INLINE
vector_of_vector (const matrix_expression<AE> &ae):
matrix_expression<self_type> (),
size1_ (ae ().size1 ()), size2_ (ae ().size2 ()), data_ (1) {
resize (ae ().size1 (), ae ().size2 (), false);
matrix_assign (scalar_assign<reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
}
// Accessors
BOOST_UBLAS_INLINE
size_type size1 () const {
return size1_;
}
BOOST_UBLAS_INLINE
size_type size2 () const {
return size2_;
}
BOOST_UBLAS_INLINE
const_array_type &data () const {
return data_;
}
BOOST_UBLAS_INLINE
array_type &data () {
return data_;
}
// Resizing
BOOST_UBLAS_INLINE
void resize (size_type size1, size_type size2, bool preserve = true) {
size1_ = size1;
size2_ = size2;
detail::resize (data (), functor_type::size1 (size1, size2) + 1, preserve);
for (size_type k = 0; k < functor_type::size1 (size1, size2); ++ k)
detail::resize (data () [k], functor_type::size2 (size1, size2), preserve);
}
// Element access
BOOST_UBLAS_INLINE
const_reference operator () (size_type i, size_type j) const {
return data () [functor_type::element1 (i, size1_, j, size2_)] [functor_type::element2 (i, size1_, j, size2_)];
}
BOOST_UBLAS_INLINE
reference operator () (size_type i, size_type j) {
return data () [functor_type::element1 (i, size1_, j, size2_)] [functor_type::element2 (i, size1_, j, size2_)];
}
// Assignment
BOOST_UBLAS_INLINE
vector_of_vector &operator = (const vector_of_vector &m) {
// Precondition for container relaxed as requested during review.
// BOOST_UBLAS_CHECK (size1_ == m.size1_, bad_size ());
// BOOST_UBLAS_CHECK (size2_ == m.size2_, bad_size ());
size1_ = m.size1_;
size2_ = m.size2_;
data () = m.data ();
return *this;
}
BOOST_UBLAS_INLINE
vector_of_vector &assign_temporary (vector_of_vector &m) {
swap (m);
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
vector_of_vector &operator = (const matrix_expression<AE> &ae) {
#ifdef BOOST_UBLAS_MUTABLE_TEMPORARY
return assign_temporary (self_type (ae));
#else
// return assign (self_type (ae));
self_type temporary (ae);
return assign_temporary (temporary);
#endif
}
template<class AE>
BOOST_UBLAS_INLINE
vector_of_vector &reset (const matrix_expression<AE> &ae) {
self_type temporary (ae);
resize (temporary.size1 (), temporary.size2 (), false);
return assign_temporary (temporary);
}
template<class AE>
BOOST_UBLAS_INLINE
vector_of_vector &assign (const matrix_expression<AE> &ae) {
matrix_assign (scalar_assign<reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
vector_of_vector& operator += (const matrix_expression<AE> &ae) {
#ifdef BOOST_UBLAS_MUTABLE_TEMPORARY
return assign_temporary (self_type (*this + ae));
#else
// return assign (self_type (*this + ae));
self_type temporary (*this + ae);
return assign_temporary (temporary);
#endif
}
template<class AE>
BOOST_UBLAS_INLINE
vector_of_vector &plus_assign (const matrix_expression<AE> &ae) {
matrix_assign (scalar_plus_assign<reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
return *this;
}
template<class AE>
BOOST_UBLAS_INLINE
vector_of_vector& operator -= (const matrix_expression<AE> &ae) {
#ifdef BOOST_UBLAS_MUTABLE_TEMPORARY
return assign_temporary (self_type (*this - ae));
#else
// return assign (self_type (*this - ae));
self_type temporary (*this - ae);
return assign_temporary (temporary);
#endif
}
template<class AE>
BOOST_UBLAS_INLINE
vector_of_vector &minus_assign (const matrix_expression<AE> &ae) {
matrix_assign (scalar_minus_assign<reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
return *this;
}
template<class AT>
BOOST_UBLAS_INLINE
vector_of_vector& operator *= (const AT &at) {
matrix_assign_scalar (scalar_multiplies_assign<reference, AT> (), *this, at);
return *this;
}
template<class AT>
BOOST_UBLAS_INLINE
vector_of_vector& operator /= (const AT &at) {
matrix_assign_scalar (scalar_divides_assign<reference, AT> (), *this, at);
return *this;
}
// Swapping
BOOST_UBLAS_INLINE
void swap (vector_of_vector &m) {
// Too unusual semantic.
// BOOST_UBLAS_CHECK (this != &m, external_logic ());
if (this != &m) {
// Precondition for container relaxed as requested during review.
// BOOST_UBLAS_CHECK (size1_ == m.size1_, bad_size ());
// BOOST_UBLAS_CHECK (size2_ == m.size2_, bad_size ());
std::swap (size1_, m.size1_);
std::swap (size2_, m.size2_);
data ().swap (m.data ());
}
}
#ifndef BOOST_UBLAS_NO_MEMBER_FRIENDS
BOOST_UBLAS_INLINE
friend void swap (vector_of_vector &m1, vector_of_vector &m2) {
m1.swap (m2);
}
#endif
// Element insertion and erasure
// These functions should work with std::vector.
// Thanks to Kresimir Fresl for spotting this.
BOOST_UBLAS_INLINE
void insert (size_type i, size_type j, const_reference t) {
BOOST_UBLAS_CHECK (data () [functor_type::element1 (i, size1_, j, size2_)] [functor_type::element2 (i, size1_, j, size2_)] == value_type (), bad_index ());
data () [functor_type::element1 (i, size1_, j, size2_)] [functor_type::element2 (i, size1_, j, size2_)] = t;
}
BOOST_UBLAS_INLINE
void erase (size_type i, size_type j) {
data () [functor_type::element1 (i, size1_, j, size2_)] [functor_type::element2 (i, size1_, j, size2_)] = value_type ();
}
BOOST_UBLAS_INLINE
void clear () {
for (size_type k = 0; k < functor_type::size1 (size1_, size2_); ++ k)
// data () [k].clear ();
std::fill (data () [k].begin (), data () [k].end (), value_type ());
}
#ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
typedef indexed_iterator1<self_type, dense_random_access_iterator_tag> iterator1;
typedef indexed_iterator2<self_type, dense_random_access_iterator_tag> iterator2;
typedef indexed_const_iterator1<self_type, dense_random_access_iterator_tag> const_iterator1;
typedef indexed_const_iterator2<self_type, dense_random_access_iterator_tag> const_iterator2;
#else
class const_iterator1;
class iterator1;
class const_iterator2;
class iterator2;
#endif
#ifdef BOOST_MSVC_STD_ITERATOR
typedef reverse_iterator_base1<const_iterator1, value_type, const_reference> const_reverse_iterator1;
typedef reverse_iterator_base1<iterator1, value_type, reference> reverse_iterator1;
typedef reverse_iterator_base2<const_iterator2, value_type, const_reference> const_reverse_iterator2;
typedef reverse_iterator_base2<iterator2, value_type, reference> reverse_iterator2;
#else
typedef reverse_iterator_base1<const_iterator1> const_reverse_iterator1;
typedef reverse_iterator_base1<iterator1> reverse_iterator1;
typedef reverse_iterator_base2<const_iterator2> const_reverse_iterator2;
typedef reverse_iterator_base2<iterator2> reverse_iterator2;
#endif
// Element lookup
BOOST_UBLAS_INLINE
const_iterator1 find1 (int rank, size_type i, size_type j) const {
#ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
return const_iterator1 (*this, i, j);
#else
return const_iterator1 (*this, i, j, data () [functor_type::address1 (i, size1_, j, size2_)].begin () + functor_type::address2 (i, size1_, j, size2_));
#endif
}
BOOST_UBLAS_INLINE
iterator1 find1 (int rank, size_type i, size_type j) {
#ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
return iterator1 (*this, i, j);
#else
return iterator1 (*this, i, j, data () [functor_type::address1 (i, size1_, j, size2_)].begin () + functor_type::address2 (i, size1_, j, size2_));
#endif
}
BOOST_UBLAS_INLINE
const_iterator2 find2 (int rank, size_type i, size_type j) const {
#ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
return const_iterator2 (*this, i, j);
#else
return const_iterator2 (*this, i, j, data () [functor_type::address1 (i, size1_, j, size2_)].begin () + functor_type::address2 (i, size1_, j, size2_));
#endif
}
BOOST_UBLAS_INLINE
iterator2 find2 (int rank, size_type i, size_type j) {
#ifdef BOOST_UBLAS_USE_INDEXED_ITERATOR
return iterator2 (*this, i, j);
#else
return iterator2 (*this, i, j, data () [functor_type::address1 (i, size1_, j, size2_)].begin () + functor_type::address2 (i, size1_, j, size2_));
#endif
}
// Iterators simply are pointers.
#ifndef BOOST_UBLAS_USE_INDEXED_ITERATOR
class const_iterator1:
public container_const_reference<vector_of_vector>,
public random_access_iterator_base<dense_random_access_iterator_tag,
const_iterator1, value_type> {
public:
typedef dense_random_access_iterator_tag iterator_category;
#ifdef BOOST_MSVC_STD_ITERATOR
typedef const_reference reference;
#else
typedef typename vector_of_vector::difference_type difference_type;
typedef typename vector_of_vector::value_type value_type;
typedef typename vector_of_vector::const_reference reference;
typedef typename vector_of_vector::const_reference pointer;
#endif
typedef const_iterator2 dual_iterator_type;
typedef const_reverse_iterator2 dual_reverse_iterator_type;
// Construction and destruction
BOOST_UBLAS_INLINE
const_iterator1 ():
container_const_reference<self_type> (), i_ (), j_ (), it_ () {}
BOOST_UBLAS_INLINE
const_iterator1 (const self_type &m, size_type i, size_type j, const const_iterator_type &it):
container_const_reference<self_type> (m), i_ (i), j_ (j), it_ (it) {}
BOOST_UBLAS_INLINE
const_iterator1 (const iterator1 &it):
container_const_reference<self_type> (it ()), i_ (it.i_), j_ (it.j_), it_ (it.it_) {}
// Arithmetic
BOOST_UBLAS_INLINE
const_iterator1 &operator ++ () {
++ i_;
const self_type &m = (*this) ();
if (functor_type::fast1 ())
++ it_;
else
it_ = m.find1 (1, i_, j_).it_;
return *this;
}
BOOST_UBLAS_INLINE
const_iterator1 &operator -- () {
-- i_;
const self_type &m = (*this) ();
if (functor_type::fast1 ())
-- it_;
else
it_ = m.find1 (1, i_, j_).it_;
return *this;
}
BOOST_UBLAS_INLINE
const_iterator1 &operator += (difference_type n) {
i_ += n;
const self_type &m = (*this) ();
it_ = m.find1 (1, i_, j_).it_;
return *this;
}
BOOST_UBLAS_INLINE
const_iterator1 &operator -= (difference_type n) {
i_ -= n;
const self_type &m = (*this) ();
it_ = m.find1 (1, i_, j_).it_;
return *this;
}
BOOST_UBLAS_INLINE
difference_type operator - (const const_iterator1 &it) const {
BOOST_UBLAS_CHECK (&(*this) () == &it (), external_logic ());
BOOST_UBLAS_CHECK (index2 () == it.index2 (), bad_index ());
return index1 () - it.index1 ();
}
// Dereference
BOOST_UBLAS_INLINE
reference operator * () const {
BOOST_UBLAS_CHECK (index1 () < (*this) ().size1 (), bad_index ());
BOOST_UBLAS_CHECK (index2 () < (*this) ().size2 (), bad_index ());
return *it_;
}
#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
BOOST_UBLAS_INLINE
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -