33 #ifndef SHARK_LINALG_BLAS_MATRIX_PROXY_HPP 34 #define SHARK_LINALG_BLAS_MATRIX_PROXY_HPP 43 class matrix_reference:
public matrix_expression<matrix_reference<M> > {
45 typedef typename M::size_type size_type;
46 typedef typename M::difference_type difference_type;
47 typedef typename M::value_type value_type;
48 typedef typename M::scalar_type scalar_type;
54 typedef typename M::index_type index_type;
185 const_row_iterator
row_end(index_type i)
const {
208 row_iterator
set_element(row_iterator pos, index_type index, value_type value) {
209 return expression().set_element(pos,index,value);
233 expression().reserve_column(column,non_zeros);
260 typedef typename M::size_type size_type;
261 typedef typename M::difference_type difference_type;
262 typedef typename M::value_type value_type;
263 typedef typename M::scalar_type scalar_type;
269 typedef typename M::index_type index_type;
273 typedef typename closure<M>::type matrix_closure_type;
276 typedef typename M::orientation::transposed_orientation
orientation;
288 typename boost::disable_if<
400 const_row_iterator
row_end(index_type i)
const {
425 major_iterator
set_element(major_iterator pos, index_type index, value_type value){
426 return expression().set_element(pos,index,value);
429 major_iterator
clear_range(major_iterator start, major_iterator end){
449 expression().reserve_column(column,non_zeros);
464 matrix_closure_type m_expression;
481 return trans(static_cast<M&>(m));
487 typedef M matrix_type;
488 typedef std::size_t size_type;
489 typedef typename M::difference_type difference_type;
490 typedef typename M::value_type value_type;
491 typedef typename M::scalar_type scalar_type;
497 typedef typename M::index_type index_type;
501 typedef typename closure<M>::type matrix_closure_type;
514 :m_expression(other.
expression()),m_i(other.index()){}
573 return m_expression(m_i, j);
575 reference operator [](index_type j)
const {
587 return assign(*
this,
typename vector_temporary<M>::type(e));
590 return assign(*
this,
typename vector_temporary<M>::type(e));
606 const_iterator
end()
const{
610 iterator
set_element(iterator pos, index_type index, value_type value) {
612 typename M::orientation(),
typename iterator::iterator_category()
618 typename M::orientation(),
typename iterator::iterator_category()
624 typename M::orientation(),
typename iterator::iterator_category()
642 iterator
set_element(iterator pos, index_type index, value_type value, row_major, Tag) {
643 return expression().set_element(pos,index,value);
646 iterator
clear_range(iterator start, iterator end, row_major, Tag) {
654 iterator
set_element(iterator pos, index_type index, value_type value,
656 dense_random_access_iterator_tag
665 dense_random_access_iterator_tag t
667 return set_element(pos,pos.index(),value_type(),m,t);
671 dense_random_access_iterator_tag t
673 for(;start != end; ++start)
679 matrix_closure_type m_expression;
696 return row(static_cast<M&>(expression), i);
702 typedef M matrix_type;
703 typedef std::size_t size_type;
704 typedef typename M::difference_type difference_type;
705 typedef typename M::value_type value_type;
706 typedef typename M::scalar_type scalar_type;
712 typedef typename M::index_type index_type;
716 typedef typename closure<M>::type matrix_closure_type;
724 :m_expression(expression), m_j(j) {
730 :m_expression(other.
expression()),m_j(other.index()){}
789 return m_expression(i,m_j);
791 reference operator [](index_type i)
const {
803 return assign(*
this,
typename vector_temporary<M>::type(e));
806 return assign(*
this,
typename vector_temporary<M>::type(e));
811 typedef typename column_iterator<M>::type
iterator;
822 const_iterator
end()
const{
826 iterator
set_element(iterator pos, index_type index, value_type value) {
828 typename M::orientation(),
typename iterator::iterator_category()
834 typename M::orientation(),
typename iterator::iterator_category()
840 typename M::orientation(),
typename iterator::iterator_category()
858 iterator
set_element(iterator pos, index_type index, value_type value, column_major, Tag) {
859 return expression().set_element(pos,index,value);
862 iterator
clear_range(iterator start, iterator end, column_major, Tag) {
870 iterator
set_element(iterator pos, index_type index, value_type value,
872 dense_random_access_iterator_tag
881 dense_random_access_iterator_tag t
883 return set_element(pos,pos.index(),value_type(),m,t);
887 dense_random_access_iterator_tag t
889 for(;start != end; ++start)
895 matrix_closure_type m_expression;
912 return column(static_cast<M&>(expression), j);
919 typedef M matrix_type;
920 typedef std::size_t size_type;
921 typedef typename M::difference_type difference_type;
922 typedef typename M::value_type value_type;
923 typedef typename M::scalar_type scalar_type;
929 typedef typename M::index_type index_type;
933 typedef typename closure<M>::type matrix_closure_type;
941 m_expression(expression), m_range1(r1), m_range2(r2) {
942 SIZE_CHECK (m_range1.start() <= expression.size1());
943 SIZE_CHECK (m_range1.start() + m_range1.size () <= expression.size1());
944 SIZE_CHECK (m_range2.start() <= expression.size2());
945 SIZE_CHECK (m_range2.start() + m_range2.size() <= expression.size2());
946 SIZE_CHECK (m_range1.size() == m_range2.size());
951 :m_expression(other.
expression()),m_range1(other.range1()),m_range2(other.range2()){}
955 return m_range1.start();
958 return m_range2.start();
981 return m_range1.size();
990 expression().set_element(m_range1(i),m_range2(i),t);
1008 return m_expression(m_range1(i), m_range2(i));
1010 reference operator [](index_type i)
const {
1018 return assign(*
this,
typename vector_temporary<M>::type(e));
1026 return const_iterator(*
this, 0);
1029 return const_iterator(*
this,
size());
1033 return iterator(*
this, 0);
1036 return iterator(*
this,
size());
1044 matrix_closure_type m_expression;
1083 return diag(static_cast<M&>(mat));
1090 typedef M matrix_type;
1091 typedef std::size_t size_type;
1092 typedef typename M::difference_type difference_type;
1093 typedef typename M::value_type value_type;
1094 typedef typename M::scalar_type scalar_type;
1100 typedef typename M::index_type index_type;
1104 typedef typename closure<M>::type matrix_closure_type;
1114 :m_expression(expression), m_range1(r1), m_range2(r2) {
1115 SIZE_CHECK(r1.start() <= expression.size1());
1116 SIZE_CHECK(r1.start() +r1.size() <= expression.size1());
1117 SIZE_CHECK(r2.start() <= expression.size2());
1118 SIZE_CHECK(r2.start() +r2.size() <= expression.size2());
1125 typename boost::disable_if<
1126 boost::is_same<E,matrix_range>
1129 , m_range1(other.range1())
1130 , m_range2(other.range2()){}
1134 return m_range1.start();
1137 return m_range2.start();
1141 return m_expression;
1144 return m_expression;
1160 return m_range1.size();
1164 return m_range2.size();
1191 return m_expression(m_range1(i), m_range2(j));
1197 return assign(*
this,
typename matrix_temporary<matrix_range>::type(e));
1201 return assign(*
this,
typename matrix_temporary<E>::type(e));
1226 start2()+
size2(),start2()
1232 start2()+
size2(),start2()
1250 start1()+
size1(),start1()
1256 start1()+
size1(),start1()
1261 major_iterator
set_element(major_iterator pos, index_type index, value_type value) {
1262 return expression().set_element(pos.inner(),index+orientation::index_m(start1(),start2()),value);
1269 major_iterator
clear_range(major_iterator start, major_iterator end) {
1270 return major_iterator(
expression().
clear_range(start.inner(),end.inner()),orientation::size_m(start1(),start2()));
1274 for(index_type i = 0; i != orientation::index_M(
size1(),
size2()); ++i)
1275 clear_range(major_begin(*
this,i),major_end(*
this,i));
1282 matrix_closure_type m_expression;
1291 std::size_t start1, std::size_t stop1,
1292 std::size_t start2, std::size_t stop2
1303 std::size_t start1, std::size_t stop1,
1304 std::size_t start2, std::size_t stop2
1316 std::size_t start1, std::size_t stop1,
1317 std::size_t start2, std::size_t stop2
1319 return subrange(static_cast<M&>(expression),start1,stop1,start2,stop2);
1325 std::size_t start, std::size_t stop
1335 std::size_t start, std::size_t stop
1345 std::size_t start, std::size_t stop
1347 return rows(static_cast<M&>(expression),start,stop);
1353 typename M::index_type start,
typename M::index_type stop
1363 typename M::index_type start,
typename M::index_type stop
1373 std::size_t start, std::size_t stop
1375 return columns(static_cast<M&>(expression),start,stop);
1378 template<
class T,
class Orientation=row_major>
1385 typedef std::size_t size_type;
1386 typedef std::ptrdiff_t difference_type;
1387 typedef typename boost::remove_const<T>::type value_type;
1388 typedef value_type scalar_type;
1394 typedef std::size_t index_type;
1408 : m_values(expression.
storage())
1409 , m_size1(expression.
size1())
1410 , m_size2(expression.
size2())
1411 , m_stride1(expression.
stride1())
1412 , m_stride2(expression.
stride2())
1421 : m_values(expression().
storage())
1422 , m_size1(expression().
size1())
1423 , m_size2(expression().
size2())
1424 , m_stride1(expression().
stride1())
1425 , m_stride2(expression().
stride2())
1427 BOOST_STATIC_ASSERT((
1428 boost::is_same<typename E::orientation,orientation>::value
1438 : m_values(expression().
storage())
1439 , m_size1(expression().
size1())
1440 , m_size2(expression().
size2())
1441 , m_stride1(expression().
stride1())
1442 , m_stride2(expression().
stride2())
1444 BOOST_STATIC_ASSERT(
1445 (boost::is_same<typename E::orientation,orientation>::value)
1467 m_stride1= Orientation::stride1(m_size1,m_size2);
1469 m_stride2= Orientation::stride2(m_size1,m_size2);
1507 return assign(*
this,
typename matrix_temporary<self_type>::type(e));
1513 return assign(*
this,
typename matrix_temporary<self_type>::type(e));
1521 return m_values[i*m_stride1+j*m_stride2];
1524 return m_values[i*m_stride1+j*m_stride2];
1527 m_values[i*m_stride1+j*m_stride2] = t;
1569 major_iterator
set_element(major_iterator pos, index_type index, value_type value) {
1576 *elem = value_type();
1580 major_iterator
clear_range(major_iterator start, major_iterator end) {
1581 std::fill(start,end,value_type());
1587 for(index_type i = 0; i !=
size1(); ++i){
1588 for(index_type j = 0; j !=
size2(); ++j){
1589 (*this)(i,j) = value_type();
1597 difference_type m_stride1;
1598 difference_type m_stride2;
1608 template <
class T, std::
size_t M, std::
size_t N>
1615 typename boost::enable_if<
1616 boost::is_same<typename V::storage_category,dense_tag>,
1618 typename boost::remove_reference<typename V::reference>::type
1625 typedef typename boost::remove_reference<typename V::reference>::type ElementType;
1631 typename boost::enable_if<
1632 boost::is_same<typename V::storage_category,dense_tag>,
1643 typename boost::enable_if<
1644 boost::is_same<typename E::storage_category,dense_tag>,
1646 typename boost::remove_reference<typename E::reference>::type
1653 return to_matrix(static_cast<E&>(v),size1,size2);